Download Method Summary - Departament d`Enginyeria Informàtica i

PROYECTO FINAL DE CARRERA
Estudio para la implementación de un
sistema de razonamiento basado en casos
Manuel Miguel Giménez Arjona,
manuelmiguel.gimenez@estudiants.urv.es
Ingeniería Técnica en Informática de Gestión
DIRECTORES:
Ivan López Arévalo
Aïda Valls Mateu
Escola Tècnica Superior d’Enginyeria (ETSE)
Universitat Rovira i Virgili (URV)
http://www.etse.urv.es
Curso 2005-06
Estudio para la implementación de un sistema de razonamiento basado en casos
RESUMEN
Este proyecto abordará una investigación general sobre los sistemas de razonamiento basados en
casos. El lector podrá comprender desde un comienzo el significado de dichos sistemas, su
funcionamiento, metodología y dominios en los que es posible su aplicación. En el documento se
presenta una revisión bibliográfica de aquellos autores que mejoraron la metodología o la
eficiencia de estos sistemas, así como también una revisión bibliográfica de las diferentes
técnicas fusionadas que ofrecieron un notable incremento en la calidad del sistema. Así mismo
también se estudiaran algunos de los diferentes sistemas de razonamiento existentes, tanto
académicos, como comerciales. Finalmente se implementa un módulo genérico de razonamiento
basado en casos para definición, gestión, recuperación y retención de casos. Este módulo es
independiente del dominio de aplicación.
1
Estudio para la implementación de un sistema de razonamiento basado en casos
CONTENIDO
1. INTRODUCCIÓN......................................................................................................... 4
1.1
Objetivos............................................................................................................ 5
2. RAZONAMIENTO BASADO EN CASOS ................................................................. 6
2.1 Origen y Evolución.................................................................................................. 7
2.2 ¿ Qué es un caso ?, significado y descripción de un caso ....................................... 8
2.3 La base de casos ...................................................................................................... 9
2.4 La metodología de CBR ........................................................................................ 11
2.5 Ventajas de CBR ................................................................................................... 11
2.6 Desventajas de CBR .............................................................................................. 12
2.7 Principales Aplicaciones........................................................................................ 12
3. EL CICLO DE CBR .................................................................................................... 15
3.1 Retrieve (Recuperación) ....................................................................................... 17
3.2 Reuse (Reutilizar) ................................................................................................. 21
2.3 Revise (Revisar) ................................................................................................... 23
2.4 Retain (Recordar) ................................................................................................. 24
4. CBR CON OTRAS TÉCNICAS ................................................................................. 26
4.1 CBR Y RBS (Rule-based systems) ...................................................................... 26
4.2 CBR y MBR (Model-based Reasoning)............................................................... 28
4.3 CBR y Lógica Difusa (Fuzzy Logic).................................................................... 31
4.4 CBR y algoritmos genéticos ................................................................................. 33
4.5 CBR y ANN (Artificial Neural Networks)........................................................... 35
4.6 CBR y Ontologías................................................................................................. 37
5. MOTORES DE CBR................................................................................................... 40
5.1 Motores académicos ............................................................................................. 40
5.1.1 Caspian .......................................................................................................... 40
5.1.2 Selection Engine ............................................................................................ 42
5.1.3 NaCoDAE...................................................................................................... 44
5.1.4 IUCBRF......................................................................................................... 45
5.1.5 Cbr-Shell........................................................................................................ 47
5.2 Motores Comerciales............................................................................................ 47
5.2.1 Kate................................................................................................................ 48
5.2.2 CBR- Works .................................................................................................. 48
5.2.3 Orenge ........................................................................................................... 49
5.2.4 ReMind .......................................................................................................... 50
5.2.5 ReCall ............................................................................................................ 50
5.2.6 ESTEEM........................................................................................................ 51
5.2.7 ART*Enterprise............................................................................................. 52
6. IMPLEMENTACIÓN DE MÓDULO GENÉRICO DE RECUPERACIÓN ............. 53
6.1 Descripción de las herramientas de software empleadas....................................... 53
6.1.1 The Selection Engine Project ........................................................................ 53
6.1.1.1 Motor de recuperación de Selection Engine............................................ 54
6.1.1.2 Clases empleadas para definir y extraer casos......................................... 57
6.1.1.3 Gestor general de clases .......................................................................... 61
6.1.2 Ozone DataBase ............................................................................................. 63
6.2 Desarrollo de la aplicación .................................................................................... 65
6.2.1 Creación de la Base de Casos ......................................................................... 65
6.2.2 El entorno de CBR Extraction Module .......................................................... 66
6.2.2.1 Conexión a la Base de Casos................................................................... 67
2
Estudio para la implementación de un sistema de razonamiento basado en casos
6.2.2.2 Definición de atributos ............................................................................ 68
6.2.2.3 Manipulación de casos ............................................................................ 69
6.2.2.4 Visualización de casos............................................................................. 72
6.2.2.5 Definición del caso base .......................................................................... 72
6.2.2.6 Presentación extendida de resultados ...................................................... 81
6.2.2.7 Definición del número máximo de casos Similares ................................ 83
7. CONCLUSIONES....................................................................................................... 84
REFERENCIAS .............................................................................................................. 86
APÉNDICES ............................................................................................................... 92
Apéndice A. Resumen de herramientas CBR.............................................................. 93
Apéndice B. Application Program Interface ............................................................... 96
Apéndice C. Código CBR Extraction Module .......................................................... 129
3
Estudio para la implementación de un sistema de razonamiento basado en casos
1. INTRODUCCIÓN
El razonamiento humano es muy extenso y se basa en razonamiento mediante ejemplos y casos,
es decir cuando una persona se encuentra con un nuevo problema, normalmente emplea
conocimiento previo para ayudarse a resolverlo, conocimiento que ha vivido y experimentado ya
que por ese motivo sabe cual será la solución aproximada a dicho problema.
Este proyecto ha sido realizado dentro del Grupo de Investigación en Inteligencia Artificial
BANZAI del Departamento de Ingeniería Informática y Matemáticas de la URV. El proyecto
abordará una investigación general sobre los sistemas de razonamiento basado en casos (en
ingles denominado Case-based Reasoning -CBR-). Se explica qué son, cuáles son sus
características principales, cuál es su funcionamiento, cuál su utilidad académica y comercial y
sus ventajas y desventajas. Así como también se presenta una revisión bibliográfica sobre
razonamiento basado en casos, técnicas de recuperación, reutilización, adaptación y retención de
diferentes sistemas. Un sistema de razonamiento basado en casos es de gran utilidad, pero en la
actualidad, numerosos científicos investigan la interacción entre los diferentes sistemas de
inteligencia. En este sentido, las posibilidades de investigación son muy amplias, ya que existe
una gran variedad de sistemas inteligentes que en combinación con otros logran un incremento la
calidad del sistema. Así mismo en este proyecto se realizara una revisión bibliográfica sobre los
diferentes sistemas híbridos con CBR que se han realizado.
El proyecto también incluye una evaluación de los diferentes motores CBR académicos y
comerciales del mercado. Se explicará su entorno de programación, dominio, la representación
de los casos, tipo de adaptación e interface. Por último se implementará un sistema genérico de
razonamiento basado en casos (recuperación y retención). Para ello se ha creado una aplicación
completa e independiente de la base de casos, que a parte de realizar las etapas de recuperación y
retención de experiencias (casos), gestiona completamente un sistema CBR. El propio
usuario/empresa además podrá crear desde cero el entorno en el que desea aplicar el sistema de
razonamiento basado en casos. En esta parte se explica con detalle la descripción y uso de las
diferentes opciones creadas en la aplicación.
En el último apartado se ofrecen las conclusiones que se han obtenido de la realización de este
proyecto. Finalmente en los apéndices finales se muestran unas tablas resúmenes sobre los
diferentes motores CBR, así como el API (Application Program Interface) y el código de la
aplicación realizada.
4
Estudio para la implementación de un sistema de razonamiento basado en casos
1.1 Objetivos
Los objetivos en la realización del proyecto han sido los siguientes:
1. Estudio y revisión bibliográfica de técnicas aplicadas en CBR.
En el segundo apartado se explicará que es un sistema CBR. Esto incluye el origen y
evolución, la definición, su metodología de funcionamiento, las ventajas y desventajas,
así como sus diferentes aplicaciones en los entornos en que son utilizados. En el tercer
apartado se indagará más exhaustivamente en el funcionamiento de un sistema CBR,
explicando y dando a conocer el ciclo básico que todo sistema basado en el
razonamiento ha de poseer. Cada apartado de este ciclo será estudiado ofreciendo una
revisión biográfica de las diferentes técnicas y métodos que emplearon los autores para
mejorar o incrementar el manejo y la eficiencia de un sistema CBR. En el cuarto
apartado se estudiará los sistemas híbridos producidos al aplicar CBR con otras áreas de
la inteligencia artificial. Se explicará en que consisten las técnicas y se ofrecerá una
revisión biográfica de los sistemas híbridos desarrollados por los diferentes autores. Que
sistemas se crearon, su campo de interacción y las mejoras obtenidas en la fusión.
2. Estudio de los diferentes motores de CBR.
En el quinto apartado se realiza un estudio sobre las diferentes herramientas CBR
comerciales y académicas halladas. De cada una de estas herramientas se estudiará su
entorno de programación, el dominio de aplicación, la metodología de recuperación de
datos, así como las diferentes técnicas utilizadas para la adaptación de los datos
recuperados. Sobre este apartado en el apéndice A se presentan unas tablas que resumen
todas estas áreas en todos los sistemas CBR.
3. Implementación de un entorno genérico de extracción para diversos dominios.
En el sexto apartado del documento se realizará la implementación de un módulo
genérico de recuperación de casos llamado CBR Extraction Module. Es genérico ya que
puede emplearse en diferentes dominios. El usuario podrá modelar un dominio nuevo
cada vez que lo desee, utilizando como medio para la modelación, gestión y cálculo de
similitudes el propio CBR Extraction Module, sin necesidad de utilizar ningún otro
módulo complementario. Para ello se describirán las herramientas empleadas, así como
la base de datos utilizada para este fin. Finalmente se describe el entorno creado, todas
sus características y usos para el usuario.
5
Estudio para la implementación de un sistema de razonamiento basado en casos
2. RAZONAMIENTO BASADO EN CASOS
CBR (Case-based Reasoning) es un conjunto de técnicas para el desarrollo de sistemas basados
en el conocimiento que recupera y reutiliza las soluciones de experiencias pasadas para resolver
problemas parecidos y así obtener los mejores resultados. De ahora en adelante, en este
documento se hará uso indistintamente a la referencia de Razonamiento Basado en Casos o
mediante el acrónimo CBR.
El razonamiento basado en casos puede verse como un subconjunto de razonamiento analógico,
el cual consiste en alterar algún episodio de la solución de un problema previo para resolver un
problema nuevo, ambos problemas relacionados de alguna manera. La diferencia es que las
analogías de razonamiento basado en casos se realizan siempre en un mismo dominio, es decir,
el problema fuente y el problema meta pertenecen al mismo dominio. A diferencia, el
razonamiento analógico encuentra similitudes entre diferentes dominios.
Un sistema CBR puede verse como un sistema experto, es decir, aquellos programas
informáticos que se realizan haciendo explícito el conocimiento codificado y almacenado en
ellos, que tienen información específica de un dominio y que ejecutan tareas relativas a este
dominio, por lo tanto, el éxito del sistema radica fundamentalmente en el conocimiento sobre el
dominio de que trata y su capacidad de aprendizaje.
Las partes más importantes de un sistema CBR son:
•
La base de casos (también llamada librería de casos) y
•
El motor de similitudes.
Un sistema CBR necesita por lo tanto de una colección de experiencias, llamadas casos,
almacenadas en una base de casos, donde cada caso se compone generalmente de una
descripción del problema y la solución que se aplicó. Así pues un sistema CBR se basa en dos
grandes hipótesis. En primer lugar que un sistema puede ser un buen solucionador de problemas
eficiente y efectivo sin necesidad de poseer un conocimiento completo de la relación que existe
entre un problema y su solución. Y en segundo lugar es que los problemas tienden a repetirse y
por ello la experiencia es un recurso útil.
6
Estudio para la implementación de un sistema de razonamiento basado en casos
2.1 Origen y Evolución
Las raíces del CBR hay que buscarlas en la psicología donde se demuestra en muchas ocasiones
que los seres humanos resolvemos problemas en base a nuestras experiencias pasadas y no ha
partir de un conocimiento profundo del problema. Los médicos, por ejemplo, buscan conjuntos
de síntomas que identifican al paciente con algún conjunto de casos previos.
Los primeros trabajos de CBR se deben gracias a Schank y Abelson [1] a finales de los años 70.
Estos trabajos se basaban en la suposición de que las personas almacenamos el conocimiento en
forma de guiones que nos permiten hacer predicciones y realizar inferencias. Estos guiones
aunque resultaron ser un modelo incompleto de memoria sirvieron como base para los trabajos
que Roger Schank y su grupo desarrollaron en la Universidad de Yale a principios de los años
80. En el Año 1982 se crea el modelo dinámico de memoria de Schank [2] y fue en el grupo de
Yale donde se sentaron las bases del CBR y se desarrollaron las primeras aplicaciones según
estas bases.
CYRUS [3, 4] fue el primer sistema CBR, desarrollado por Janet Kolodner [5] sobre los años
1983-1984 basado en el modelo dinámico de memoria de Schank. Aquí los casos representaban
conocimiento a cerca de los viajes y las entrevistas del secretario de estado americano Cyrus
Vance. Posteriormente, también en Yale se desarrollaron MEDIATOR [6] por Kolodner y
Simpson sobre los años 1984-1989, el cual que fue un sistema de arbitraje de fútbol. JUDGE [7]
desarrollado por Bain en los años 1984-1986 el cual contenía una base de casos de sentencias
resueltas para la ayuda de toma de decisiones en los casos legales. CHEF [8] creado por
Hammond en los años 1986-1989 para el diseño de recetas de comida china. PERSUADER [9]
para la construcción de argumentaciones en casos legales, CASEY [10] para el diagnóstico de
enfermedades cardiovasculares y JULIA [11] para el diseño de menús.
En los años 1986 - 1989, cabe destacar el trabajo de Bruce Porter, en la Universidad de Texas, en
la integración de casos y conocimiento que dio lugar al sistema PROTOS [12], aplicado al
diagnóstico de enfermedades del aparato auditivo.
Por otro lado cabe destacar el trabajo de Edwina Rissland de la Universidad de Massachussets en
el desarrollo del sistema HYPO [13], dicho sistema construía argumentos legales a favor y en
contra de los litigantes en base a las similitudes y diferencias con otros casos
Una de las primeras aplicaciones de CBR en funcionamiento real fue el sistema CLAVIER [14],
el desarrollo de este sistema comenzó en 1987 y sigue usándose desde 1990. Este sistema
7
Estudio para la implementación de un sistema de razonamiento basado en casos
ayudaba al proceso de seleccionar y colocar dentro del autoclave las piezas a hornear de misiles
y aviones, y para ello era necesario confiar más en la experiencia de cargas anteriores que no en
la propia ciencia. Los operarios de los autoclaves se basaban en dibujos de distribuciones
utilizadas previamente con éxito para determinar como se iba a cargar el autoclave. Se
seleccionaba una disposición que hubiera funcionado bien y se adaptaba a la situación actual.
La Unión Europea financió en la década de los 90 dos proyectos, INRECA I y II [15], dedicados
a investigar en el desarrollo de herramientas y metodologías para sistemas CBR, alrededor de los
cuales surgieron y se consolidaron dos compañías: Acknosoft en Francia y TecInno en
Alemania. Posteriormente las actividades de Acknosoft se han orientado a las aplicaciones de
diagnóstico, mientras que TecInno se especializa en aplicaciones de comercio electrónico.
Aunque inicialmente el CBR no fue acogido con buenos ojos por la comunidad de Inteligencia
Artificial por el hecho que para resolver un problema no hace falta entenderlo, sino tener una
buena base de casos parecidos. En la segunda mitad de los años 90 el CBR ha ido encontrando
su lugar en la comunidad. Tal y como se demuestra en los años 1995 y 1999 dos artículos sobre
CBR [16, 17], los cuales recibieron el premio al mejor artículo de investigación en el IJCAI
(Internacional Join Conference on Artificial Intelligence), la conferencia más importante de
Inteligencia Artificial.
2.2 ¿Qué es un caso?, significado y descripción de un caso
El principal activo de un sistema CBR es la base de casos. Un caso contiene información útil en
un contexto concreto, el problema es identificar los atributos que caracterizan al contexto y
detectar cuándo dos contextos son similares. Un caso es una experiencia que enseña algo, de tal
manera puede haber experiencias que no aporten ninguna nueva información al sistema, lo cual
plantea el problema de identificar cuando dos casos son superficialmente distintos. Además lo
que el caso enseña es relativo a unos determinados objetivos, y por lo tanto, se ha de tener en
cuenta que una determinada solución puede fallar, en CBR interesa no solo guardar las
soluciones que funcionan sino también aquellas otras que fallaron, ya que ambas contienen
información útil que permitirá repetir las soluciones exitosas, y evitar la repetición de las
fallidas.
8
Estudio para la implementación de un sistema de razonamiento basado en casos
Generalmente un caso se compone de las siguientes partes:
1. La descripción de un problema, ya sea la situación a interpretar, el problema de
planificación a resolver o el artefacto a diseñar. Esta es la parte de casos que se utiliza
para determinar su similitud.
2. La descripción de una solución. Además del artefacto construido, el plan aplicado o la
interpretación asignada. En la solución de un caso se puede guardar información
adicional, sobre todo con el objetivo de facilitar futuras adaptaciones. Información
acerca del proceso que llevó a la obtención de la solución, qué alternativas se
consideraron, cuáles se eligieron y cuáles se descartaron, y el motivo de la elección o el
rechazo de dicho caso.
Esta es una estructura general, es decir, se pueden encontrar casos en los que tan solo estén
compuestos de la descripción del problema y de la solución aplicada. Pero también se pueden
encontrar casos en los que no se hace una distinción entre las partes de un caso, sino que cada
caso esta descrito por un conjunto de atributos, y una consulta solo contiene una parte de ellos,
de forma que el problema son los atributos contenidos en la consulta y la solución los que no
están. Esto es típico en las aplicaciones de diseño.
Gracias al concepto de guardar las experiencias en forma de casos se obtienen unas ventajas
sobre otros sistemas. Las ventajas son:
•
A los expertos les resulta más fácil proporcionar ejemplos, que no crear reglas de
comportamiento.
•
Se puede obtener un nuevo caso cada vez que se resuelve un nuevo problema, se puede
indicar su resultado, explicarlo y clasificarlo como fracaso o éxito. Ya que un caso
clasificado como fracaso es también información útil.
•
Es posible comparar los casos y adaptarlos de manera efectiva.
•
Los casos mantienen su vigencia durante bastante tiempo, es decir, los problemas tienden a
repetirse.
2.3 La base de casos
Como se ha dicho anteriormente, la base de casos es el principal activo de un sistema CBR y
estaría formada por todas las experiencias representadas en forma de casos, ya sean casos en que
la solución fue la correcta o casos incorrectos. Los entornos en los que se puede crear una base
de datos con casos son muy variados y al mismo tiempo pueden ser muy complejos.
9
Estudio para la implementación de un sistema de razonamiento basado en casos
En la Figura 1, se puede ver ejemplos de casos en un dominio de atención al cliente para
solucionar problemas con impresoras. La base de casos estaría compuesta de n casos basados en
las experiencias de un experto. Como se puede apreciar cada caso se compone de una serie de
atributos y su valor correspondiente. Se puede observar que en esta base de casos, un caso está
definido por los atributos: descripción, modelo, luz estado papel, luz estado tinta color, luz
estado tinta negra y interruptor impresora. El último atributo corresponde a la solución a los
atributos planteados. Este ejemplo es muy sencillo, sirve para ilustrar un caso, pero los casos por
norma general estarán definidos con bastantes más atributos de los que se ve en el ejemplo.
C
A
S
O
1
PROBLEMA
DESCRIPCIÓN: Impresora no imprime
MODELO: Epson stylus Color 700
LUZ ESTADO PAPEL: Apagada
LUZ ESTADO TINTA COLOR: Apagada
LUZ ESTADO TINTA NEGRA: Encendida
INTERRUPTOR IMPRESORA: Encendida
SOLUCION
CAMBIAR CARTUCHO DE TINTA
C
A
S
O
2
PROBLEMA
DESCRIPCIÓN: Impresora no imprime
MODELO: Epson stylus Color 700
LUZ ESTADO PAPEL: Apagada
LUZ ESTADO TINTA COLOR: Encendida
LUZ ESTADO TINTA NEGRA: Apagada
INTERRUPTOR IMPRESORA: Encendida
SOLUCION
CAMBIAR CARTUCHO DE TINTA
C
A
S
O
N
PROBLEMA
DESCRIPCIÓN: Impresora no imprime
MODELO: Epson stylus Color 700
LUZ ESTADO PAPEL: Encendida
LUZ ESTADO TINTA COLOR: Apagada
LUZ ESTADO TINTA NEGRA: Apagada
INTERRUPTOR IMPRESORA: Encendida
SOLUCION
REPONER PAPEL EN LA IMPRESORA
Figura 1. Esquema de representación de una base de casos.
10
BASE
DE
CASOS
Estudio para la implementación de un sistema de razonamiento basado en casos
2.4 La metodología de CBR
En la Figura 2 podemos ver de forma muy sencilla cómo se obtiene la solución a un problema
nuevo. Gracias a que se dispone un espacio de problemas con las descripciones de los casos se
puede buscar el caso más parecido al problema planteado por conocimiento de similitud. La
solución de este caso parecido, equivaldrá a una posible solución del caso nuevo.
Espacio de
Problemas
Descripción del
problema nuevo
Espacio de
Soluciones
Solución
Propuesta al
nuevo caso
Figura 2. Metodología de CBR.
Este funcionamiento es lo que se implementa en el motor de razonamiento mediante sistemas
expertos, sistemas de producción, etc.
2.5 Ventajas de CBR
En primer lugar el CBR facilita la adquisición de conocimiento porque a los expertos les resulta
mucho más fácil solucionar el caso que proponer reglas de aplicación general. Un segundo
aspecto favorable del CBR como tecnología para el desarrollo de sistemas basados en el
conocimiento es que facilita el aprendizaje. De la manera más sencilla un sistema CBR puede
aprender por simple acumulación de casos, ya que cada vez que se soluciona un nuevo problema
este puede ser incorporado como un nuevo caso a la base de casos. Un tercer aspecto a
considerar es que gracias al CBR se pueden proponer soluciones en dominios poco formalizados
o que no se comprenden del todo, no es necesario que toda la información del dominio esté
completa.
11
Estudio para la implementación de un sistema de razonamiento basado en casos
Otras ventajas del CBR son:
•
Permite construir razonadores más eficientes, puesto que suele ser menos costoso modificar
una solución previa que construir una nueva solución desde cero.
•
Los casos pueden proporcionar también “información negativa”, alertando sobre posibles
fallos.
•
Se facilita el mantenimiento de la base de conocimiento, ya que los usuarios pueden añadir
nuevos casos sin ayuda de los expertos.
•
Es más fácil conseguir que los usuarios acepten las sugerencias del sistema ya que estas
están avaladas por una situación previa.
2.6 Desventajas de CBR
Como en todo sistema, este, aparte de ventajas también existen desventajas que se han de tener
presente a la hora de utilizar un sistema CBR. Estas desventajas son descritas a continuación:
•
El razonamiento basado en casos no pretende encontrar la solución exacta al problema. El
usuario recupera soluciones óptimas basadas en experiencias pasadas.
•
El cálculo de la similitud entre el nuevo caso y los existentes en la base de casos puede
resultar extremadamente complejo.
•
“Comienzo frío”, es decir, al principio si un sistema CBR contiene pocos casos y esto hace
que el sistema no pueda ofrecer buenas soluciones.
•
El usuario ha de interpretar la medida de similitud para justificar la solución que el sistema
le ha ofrecido.
2.7 Principales Aplicaciones
Janet kolodner [18] describe una serie de características que permiten identificar aquellos
dominios en los que la aproximación basada en casos tiene probabilidades de éxito. Las
aplicaciones de los sistemas CBR se pueden clasificar en dos grandes grupos:
1. Clasificación e interpretación de situaciones
2. Resolución de problemas
12
Estudio para la implementación de un sistema de razonamiento basado en casos
En general las aplicaciones industriales están dentro del primer grupo, donde las técnicas a
utilizar están mejor definidas, la representación de los casos es más sencilla y existen
herramientas comerciales que soportan el desarrollo. Los sistemas de resolución de problemas,
por el contrario son más habituales en el ámbito académico ya que necesitan representaciones
más complicadas y más esfuerzo de adquisición y formalización de conocimiento.
En el ámbito de los sistemas CBR de clasificación e interpretación destacan los siguientes
dominios de aplicación:
•
Servicios de atención al cliente (help-desk). Este es el dominio donde más éxito han tenido
los sistemas CBR fuera del mundo académico. El problema fundamental de los servicios de
atención al cliente al cliente es básicamente económico: si el producto sobre el que se presta
soporte es sofisticado, entonces es necesario que la persona que resuelve las dudas de los
clientes sea un experto, pero claro, a una empresa le resulta muy costoso dedicar personal
cualificado a una tarea repetitiva, ya que los problemas de los clientes tienden a repetirse.
La solución basada en CBR consiste en construir una base de casos con los problemas
resueltos de los expertos y encargar a una persona menos cualificada de atender a los
clientes. De esta forma el experto sólo será consultado cuando el cliente planteé un problema
que no haya sido resuelto previamente. Naturalmente cada vez que los expertos resuelven un
nuevo problema, éste pasa a formar parte de la base de casos.
•
Diagnóstico y resolución de fallos. Los sistemas de diagnóstico basados en CBR se plantean
como herramientas de ayuda que el experto utiliza para acelerar su trabajo y que además
sirven como una “memoria corporativa” a través de la cual distintos expertos comparten el
resultado de su actividad diaria.
•
Predicción y valoración. En dominios difíciles de formalizar la casuística1 es una fuente
valiosa de predicciones, y por lo tanto resultan aptos para las aproximaciones basadas en
casos. Desde el punto de vista técnico, la principal dificultad en el desarrollo en este tipo de
sistemas radica en establecer cuales son los atributos predictivos que permitan determinar la
similitud entre una situación pasada y la actual.
•
Enseñanza. Diversos pedagogos argumentan sobre las ventajas de la enseñanza basada en
ejemplos y es por ello que se han desarrollado trabajos dentro de lo que se llama “enseñanza
1
Consideración de los diversos casos particulares que se pueden prever en determinado dominio.
13
Estudio para la implementación de un sistema de razonamiento basado en casos
basada en casos”. Un sistema de este tipo suele incluir, además de un conjunto de ejemplos
de valor pedagógico, un entorno simulado donde el alumno realiza algún tipo de interacción,
de forma que en base a dicha interacción, el sistema sea capaz de sugerir ejemplos que
aporten información relevante a la tarea que en ese momento se esté realizando.
•
Comercio electrónico. En este dominio se han realizado algunos trabajos que sacan partido
de los procesos de “recuperación aproximada” propios del CBR. En los sistemas de
comercio electrónico convencionales, la interfaz de consulta consiste en un catálogo y/o
formulario de consulta a base de datos. El inconveniente de las consultas a base de datos es
que recuperan lo que el usuario pide y solo eso, lo que en muchas ocasiones acaba siendo
una lista de resultados vacía o demasiado larga. Si se dispone de una función de similitud
entre descripciones, se podrá ofrecer productos parecidos que puedan interesar al cliente.
Por lo que se refiere a los sistemas CBR de resolución de problemas, sus aplicaciones se
restringen casi exclusivamente al ámbito académico en dos áreas de inteligencia artificial:
planificación y diseño.
•
Los sistemas de planificación basados en CBR suelen adoptar estrategias mixtas, donde es
posible generar planes desde cero pero si existe un problema ya resuelto similar al actual, se
prefiere, por razones de eficiencia, modificar la solución antigua.
•
Los sistemas de diseño suelen ser más sofisticados que los de planificación, y requieren de
un de adquisición de conocimiento que los hace difícilmente realizables. CLAVIER [14] es
precisamente una de las primeras aplicaciones industriales del CBR y es precisamente un
sistema de diseño, más exactamente es un sistema de diseño para la fabricación de piezas en
aeronáutica.
14
Estudio para la implementación de un sistema de razonamiento basado en casos
3. EL CICLO DE CBR
El funcionamiento de un sistema CBR se apoya en un ciclo básico llamado ciclo CBR [19]
donde se puede ver a de forma general el funcionamiento desde que se plantea un nuevo
problema hasta que se decide insertar como nueva experiencia en la base de casos del sistema
CBR.
Los sistemas CBR se apoyan en los cuatro procesos básicos mostrados en la Figura 3:
1.- RETRIEVE (recuperar)
2.- REUSE (reutilizar)
3.- REVISE (revisar)
4.- RETAIN (recordar)
Figura 3. Ciclo de razonamiento basado en casos.
15
Estudio para la implementación de un sistema de razonamiento basado en casos
RETRIEVE (recuperar):
La recuperación de los casos más similares al caso o problema actual. Esta es una de las áreas de
investigación más activas en CBR y también donde más resultados se han obtenido. Esta área es
una de las más importantes y en ella se pueden encontrar diferentes algoritmos aplicados con
mayor o menor éxito.
REUSE (reutilizar):
Proponer como solución al problema actual la adoptada anteriormente. Aquí aparece el concepto
adaptación, que se hace necesaria cuando la solución recuperada no es directamente aplicable al
problema en curso. La adaptación puede ir desde un simple ajuste de parámetros mediante la
aplicación de ciertas formulas, hasta el uso de complejos modelos propios de los sistemas
basados en el conocimiento.
REVISE (revisar):
Evaluar los resultados de la solución propuesta para confirmar su correcto funcionamiento. Esta
área en ocasiones es automática pero en la mayoría de sistemas es un área que estará a cargo de
un operador humano.
RETAIN (recordar):
Guardar en la base de casos la nueva experiencia para que pueda ser utilizada en futuros
problemas. El recuerdo de casos es parte esencial de un sistema CBR, por lo tanto la inclusión de
nuevos casos puede dar lugar a la reorganización de la base de casos o a la definición de
estructuras de índices. A medida que aumenta el número de casos se plantean cuestiones de
eficiencia, ya que los procesos son más lentos cuantos más casos existen en la base de casos, y
por lo tanto se ha de ser más crítico a la hora de decidir que casos se incluyen en el sistema.
Existen técnicas que se ocupan de eliminar los casos poco utilizados, o de identificar familias de
casos relacionados para así mantener sólo aquellos casos que realmente aporten información al
sistema.
La forma en que se representan los casos, cómo se determina la similitud, cómo se realiza la
adaptación y cómo se decide cuantos casos hay que almacenar para conseguir una cobertura
suficiente del dominio de aplicación, son cuestiones que están relacionadas entre sí. Por ejemplo
cuantas más capacidades de adaptación tenga el sistema, menos casos hay que almacenar y más
nos acercamos a los sistemas basados en reglas. Si hay más conocimiento de adaptación,
entonces es necesario menos conocimiento de similitud.
16
Estudio para la implementación de un sistema de razonamiento basado en casos
La Figura 3 es un marco general de funcionamiento de los sistemas CBR, pero no todos los
sistemas CBR incluyen las cuatro fases del ciclo. En particular la fase de adaptación se obvia en
muchos sistemas, o se deja en manos de los usuarios.
En los siguientes apartados se describen con más detalles cada una de las fases del ciclo viendo
las técnicas utilizadas en cada una de ellas.
3.1 Retrieve (Recuperación)
El proceso de recuperación más simple consiste en recorrer secuencialmente la base de casos y
aplicar la función de similitud entre la consulta y cada caso, seleccionando todos los casos para
los que se supere cierto parentesco con el caso propuesto. Sin embargo en los sistemas reales con
un gran número de casos y una función de similitud costosa de calcular, la recuperación lineal
puede resultar muy cara al sistema.
La comunidad CBR ha desarrollado o adaptado estructuras de datos y algoritmos para realizar
este proceso eficientemente. Entre estos métodos podemos encontrar:
•
Árboles de decisión introducidos mediante el algoritmo ID3 o alguna de sus variantes. A
partir de el conjunto de casos y una vez fijados los atributos que actúan como índices, se
induce un árbol de decisión que permite recuperar en un mínimo de pasos los casos más
relevantes para una consulta dada
•
Modelos basados en memoria. Este tipo de estructuras se suelen utilizar en sistemas
sofisticados ya que no sólo sirven como estructura para optimizar el algoritmo de
recuperación sino que además incluyen conocimiento adicional en forma de generalizaciones
de los casos. En esta línea destacan los Memory Organization packages (MOPs) [2]
•
Redes de activación (Spreading Activation Networks). Este tipo de estructuras son una
adaptación de las redes neuronales donde la memoria de casos se representa como una red de
nodos interconectados. La recuperación se implementa como un proceso que activa los
nodos asociados con la consulta y propaga la activación a otros nodos.
•
Árboles k-d. Esta estructura de datos es una generalización de los árboles de decisión
desarrollada inicialmente en aplicaciones de informática gráfica. Esta estructura está pensada
17
Estudio para la implementación de un sistema de razonamiento basado en casos
para dado un conjunto de puntos repartidos en un espacio métrico k-dimensional, recuperar
eficientemente los k vecinos más próximos (k-nearest neighbors) a un punto dado. No se
plantea la recuperación del vecino más próximo porque análisis teóricos demuestran que la
complejidad de un algoritmo que recuperase el más próximo sería mucho más alta que la de
recuperar los k más próximos.
Como ya habíamos comentado la recuperación de los casos más similares al problema planteado
es una de las áreas de investigación más activas, veamos ahora una revisión de los métodos
utilizados más importantes.
Suh, Jhee, Ko y Lee [20] realizaron un sistema experto de razonamiento basado en casos para la
calidad de la formulación y el procesamiento de parámetros de productos químicos, de manera
que pudieran ofrecer la máxima calidad a los consumidores. Esta propuesta utiliza una jerarquía
de casos indexados para la recuperación de los casos y esta provisto de sofisticadas métricas de
similitud para acentuar la búsqueda. La recuperación del caso comienza seleccionando el caso
base que más se ajusta en la jerarquía de casos indexada. Entre el caso base escogido y todos los
demás de la base de casos se compara y se puntúa en base a una métrica de similitud para
encontrar el caso más parecido, por lo tanto esta medida es necesaria para tasar la similitud entre
los atributos de los casos. La similitud entre el pasado caso y el nuevo caso fue evaluada de dos
maneras diferentes:
1. Order-to-order-similarity (OOS): Evalúa la similitud entre el pasado caso y el nuevo
caso comparando los objetivos de los atributos de dos casos.
2. Order-to-result-similarity (ORS): Evalúa la similitud entre el pasado caso y el nuevo
caso comparando los Atributos del nuevo caso, y el resultado de los atributos del caso
pasado.
ORS fue un poco más preciso que OOS para evaluar la similitud entre los casos de la base de
casos.
Leake et al. [21] presentan el estudio de un programa CBR para la ayuda a la toma de decisiones
en el estampado de color de los coches. El gestor de estampado envuelve cinco principios
básicos para la integración de un sistema CBR. Estos son la interacción paralela entre el experto
y el sistema, la disponibilidad de la información cuando sea necesaria, la integración con otros
recursos para complementar la información, la realización rápida y en el menor tiempo posible
de las tareas y finalmente la captura de nuevas experiencias para su posterior consulta. Estos
principios son propios del modelo cognitivo del razonamiento basado en casos [7].
18
Estudio para la implementación de un sistema de razonamiento basado en casos
El gestor de estampado asocia cada tipo de zona del automóvil con una colección predefinida de
características. Un grupo de estas se asocian con regiones geométricas de cada zona y otro grupo
se asocian al tipo de material usado (aluminio, hierro, etc.). En el momento que el sistema
recupera los casos más parecidos se realiza un primer filtrado acuerdo la zona, por ejemplo el
parachoques, de este modo solo se recuperan los casos específicos de esta zona. Posteriormente,
el sistema utiliza la medida nearest-neighbor con pesos en sus características para la búsqueda
de los casos más parecidos. Una vez ha realizado todas las tareas, el sistema de estampado
genera un documento de los casos recuperados con el cual el experto puede comprender la
lógica aplicada por el sistema en la elección de los casos.
Katy Börner [22] describe una propuesta estructural llamada case-based structure generation
basada en la construcción de estructuras de casos por analogía conceptual (Conceptual Analogy)
para soporte a una base de casos. Según esta propuesta se han de encontrar conjuntos de
similitudes conceptuales entre el problema y la base de casos. Para encontrar la solución al
problema planteado se realiza una agrupación conceptual de casos, representándolos por grafos
en clases jerárquicas de estructura similar. Los casos son representados por conceptos, se les da
un problema y una solución parcial (Figura 4). Una vez encontrados los casos más parecidos se
generan colecciones de ellos ordenados por la similitud con el problema planteado.
Figura 4. Representación del problema y solución
Esta propuesta puede ser utilizada como soporte de diseño de tareas para aquellos dominios que
no permiten la adquisición de una consistente colección de restricciones, o reglas provenientes
de una colección de pasadas experiencias.
Gómez de Silva y Maher [23] describen un software llamado DEMEX, un sistema de ayuda para
los problemas que se plantean en el diseño de la construcción. Las estrategias de recuperación
necesitan ser definidas para que puedan proporcionar más de un solo caso en la búsqueda de la
base de casos. Por ello se definen dos estrategias :
19
Estudio para la implementación de un sistema de razonamiento basado en casos
1. Model based index. Usa el modelo de memoria para la identificación de información
relevante en la especificación inicial del diseño. La descripción de un problema consiste
en una lista de pares atributo-valor, gracias a estos pares más relevantes de la
especificación del problema y por eliminación de los menos significativos se crea una
reformulación de la especificación y se utiliza como índice para la recuperación de
casos. Este modelo consta de cuatro subprocesos, recuperación del modelo, selección del
modelo, suma de atributos de la especificación e identificación de los atributos críticos
de la especificación.
2. Case-base index. Esta estrategia esta provista de una búsqueda iterativa de la
especificación inicial del problema. Este algoritmo consta de tres pasos, recuperación de
casos, análisis de los casos recuperados y selección de un caso interesante.
Stephanie E.August y Lawrence P. Mcnamee [24] presentan una propuesta de argumento por
analogía llamada lenguaje natural. Muchas de las experiencias más valiosas están almacenadas
en forma de documentos de texto, por eso es natural tratar de la gestión de los documentos
mediante CBR. Implementan ARIEL, que es un sistema que detecta la presencia de las analogías
en una editorial de texto, identifica el origen de los componentes. Durante la comprensión del
texto AIREL crea correspondencias entre los componentes que se han detectado analogías o
modelos identificados como analogías gracias a la comparación de conceptos que se encuentra
en el texto.
Macaya et al. [25] proponen el razonamiento basado en casos como metodología para la
diagnosis y resintonía de reguladores PID (Proporcional-Integral-Derivativo). Dichos
reguladores son utilizados para sistemas en tiempo real y de ellos se desea que la señal de salida
sea proporcional a la de entrada, a su integral y a su derivada.
Los casos son estructuras de datos que permiten guardar información de las situaciones vividas
por el proceso incorporando tanto información numérica, cualitativa o descriptiva útil par la
interpretación y solución de un problema. En el sistema se propone una estructura de caso según
cuatro conceptos: especificaciones de funcionamiento, parámetros de proceso, parámetros de
regulador y evaluación del regulador. El funcionamiento deseado del regulador vendrá dado por
las especificaciones de funcionamiento. Éstas servirán en la recuperación para diferenciar entre
tipos de reguladores y a su vez permitirán incluir en la estructura de casos índices relativos a su
evaluación. Es decir si un caso registrado fue correctamente sintonizado y por tanto ser
reutilizado o por el contrario al utilizar los parámetros del regulador no se pudo cumplir con las
especificaciones requeridas.
20
Estudio para la implementación de un sistema de razonamiento basado en casos
Para la recuperación de casos el sistema utiliza el algoritmo nearest-neighbour en el que se
incluye el peso que se aplica a las variables del caso que representa la situación actual, y el peso
de las variables de los casos que se compararan. Esta función distancia puede aplicarse tanto a
las variables numéricas como a las variables simbólicas utilizadas para representar valores
cualitativos. El valor de semejanza obtenido será un valor normalizado entre 0 y 1. Siendo el 1 el
máximo nivel de semejanza y en consecuencia la igualdad. Una vez seleccionado el caso más
parecido a la situación actual, se comprueba que la evaluación que se hizo del funcionamiento
del regulador en el pasado fue buena. En el caso que esto fuera cierto se aplica la misma solución
a la nueva situación. En el caso que la evaluación que se hizo en el pasado fuera negativa sería
indicador de que si se mantienen los parámetros del regulador para la nueva situación
probablemente no funcionaria.
3.2 Reuse (Reutilizar)
Las soluciones recuperadas en la etapa anterior, corresponden a aquellos problemas vividos en el
pasado más parecidos con al problema inicial. Aquí aparece el concepto adaptación, que se hace
necesaria cuando la solución recuperada no es directamente aplicable al problema en curso. En
consecuencia las soluciones, en ocasiones han de ser adaptadas al nuevo problema para que su
correcto funcionamiento a la hora de ser reutilizadas. La fase de adaptación, normalmente será
realizada por un experto humano, pero también es posible encontrar sistemas CBR que pueden
ofrecer un ajuste de parámetros mediante la aplicación de ciertas formulas. Y también es posible
encontrar sistemas CBR que mediante la utilización de otras técnicas logren la automatización de
esta etapa, consiguiendo con ello precisión y autonomía.
Gómez de Silva y Maher [26] describen la implementación del proyecto llamado CASECAD. El
objetivo de este proyecto es proponer e implementar una representación para el diseño de casos
para soporte hacia los diseñadores a encontrar colecciones de los casos más relevantes de los
problemas propuestos. La representación de los casos está implementada usando FRAMEKIT
(software para la representación de casos) y la representación grafica de los casos es
implementada usando AutoCAD.
La adaptación del caso recuperado en CASECAD no se realiza de manera automática sino que
son los propios diseñadores los que realizan la adaptación de caso, para ello disponen de un
editor de herramientas para poder cambiar la representación del caso utilizando directamente
21
Estudio para la implementación de un sistema de razonamiento basado en casos
AutoCAD. Una vez se ha modificado el nuevo caso este pasará a ser automáticamente indexado
dentro de la base de casos.
Por otro lado, Gómez de Silva y Maher [27] han desarrollado una metodología para el diseño
estructural conceptual usando algoritmos genéticos. En la adaptación utilizan un simple
algoritmo genético (Genetic Algortihm -GA-) [28] el cual provee de técnicas importantes, de
hecho podemos encontrar tres notaciones que son muy útiles de los sistemas biológicos:
•
Phenotype, el cual puede ser el diseño de solución para sistemas.
•
Genotype, el camino para la representación o la codificación de la información usada
para producir el Phenotype.
•
Survival of the fittest, determina si un Genotype perdura en la reproducción.
En los sistemas GA el Genotype es representado normalmente como una cadena binaria, la
longitud de la cual varía con cada aplicación. La representación del Genotype permite la
combinación o la mutación para la construcción de mejores cadenas. Un algoritmo genético
simple considera una población de n cadenas y aplica los operadores de mutation, crossover y
reproduction en orden para crear la siguiente generación. Reproduction es un proceso en el cual
las cadenas son copiadas acuerdo con su funcionalidad idónea. Crossover es un proceso en el
cual las más recientes cadenas que se han reproducido son apareados aleatoriamente con cada
par de cadenas intercambiando parcialmente la información. Mutation es una alteración aleatoria
ocasional de uno de los bits en la cadena. La recuperación parcial de casos provee de una
población inicial al algoritmo. Los atributos-valor representados en los casos pueden ser
reinterpretados en el contexto de un algoritmo genético y las soluciones generadas serán
conocidas como Phenotype. De esta forma, usando algoritmos genéticos se puede adaptar un
caso.
Champán [29] y su equipo de investigación de la Universidad de Claude proponen un modelo
para la asistencia interactiva de la fase de adaptación de un sistema CBR. El principal objetivo
del proyecto ARDECO (Assisted reuse of design episodes) es estudiar como los usuarios de
sistemas CAD (Computer Aided Design) practican el reuso. Para la creación del modelado de
episodios existen dos alternativas; el modelado dinámico, que es representado por una secuencia
de operaciones, o el modelado estático visto como una secuencia de estados. Los autores utilizan
solo el modelado estático y su particular estructura ha sido nombrada "tree with shortcuts". La
figura 5 muestra un pequeño ejemplo de la estructura:
22
Estudio para la implementación de un sistema de razonamiento basado en casos
Figura 5: “tree with shortcuts”
La secuencia cronológica de los estados de la A a la E es guardado como una ruta, pero como se
puede ver en cada subestado existe un acceso directo a otro estado, de esta forma se puede ir
directamente de un estado inicial a un estado final. En el estado B se puede ver que se puede
llegar a dos estados finales, el E y el G. Durante la representación del conocimiento de
adaptación, las relaciones recuperadas entre casos son representadas mediante las flechas
curvadas, mientras que las flechas rectas representan las relaciones de reuso aplicables. Como se
puede ver en la Figura 6.
Figura 6. Representación para reuso de estados
En el momento de la adaptación el experto dispone de esta guía para comprobar las diferencias
entre los estados del caso recuperado y de esta forma ayudar en la realización de los cambios
necesarios para el correcto funcionamiento de la solución.
2.3 Revise (Revisar)
Los sistemas CBR, como se ha dicho anteriormente aprenden nuevas experiencias, nuevos casos
que aporten un enriquecimiento del sistema. Así pues después de reutilizar una posible solución
esta puede ser correcta o no, si es correcta la nueva solución será almacenada en el sistema, pero
si la solución no ha sido satisfactoria entonces se tendrá que revisar.
La revisión de casos comprende básicamente dos fases:
23
Estudio para la implementación de un sistema de razonamiento basado en casos
•
Evaluar la solución. Es decir, decidir si la solución dada es la correcta al problema
planteado. Esta fase normalmente se realizará por algún método externo al sistema CBR,
como por ejemplo el usuario. A veces es necesario realizar simulaciones.
•
Reparar los fallos. Si no es correcta la solución se han de detectar los fallos y corregirlos.
Este apartado en los sistemas CBR está bastante descuidado por la gran mayoría de autores
encontrados, mayormente las áreas más estudiadas y desarrolladas son las de recuperación de
casos y reuso (adaptación de ellos). La gran mayoría de autores dan por hecho que la adaptación
de los casos realizada de forma automática por el sistema se encuentra fundamentada en unas
reglas lógicas y acertadas. Pero como la mayoría de autores comentan existe un operador final
que después de probar la solución en la vida real puede decidir si es apta o no apta para ser
introducida en el sistema. La revisión de casos es controlada en la mayoría de sistemas por un
operador humano, es por ello, que la mayoría de autores no ofrecen investigaciones profundas
sobre este punto y se dediquen a la mejora y estudio de las otras áreas.
Leake et. al [30] presentan una propuesta de adaptación y evaluación de los casos que serán
insertados en el sistema CBR. La adaptación de los casos por parte de un sistema es una tarea
muy difícil o imposible de realizar en algunos dominios. Pero es posible realizar una adaptación
del caso utilizando otra base de casos realizada explícitamente para este fin.
La propuesta utiliza una librería de casos para la adaptación de los casos basada en la
experiencia, dichas librerías de forma más sencilla ya han sido utilizadas en otros sistemas de
razonamiento para el guiado de la adaptación de los casos [31,32]. El método, llamado RCR (Reaplication cost and relavance) se basa la observación de la adaptación que el operador realiza
sobre el caso. Es decir, el sistema encapsula esquemas de derivación propios al adaptar el caso.
De esta forma son creadas guías de ayuda al operador en el momento de la adaptación, así como
su revisión para comprobar que la adaptación se ha realizado correctamente. Pero dichas guías
no solo tienen este uso sino que también son utilizadas para predecir la dificultad de la
adaptación, para ello se da toda la información necesaria calculando los costes de adaptación de
los casos mediante estimaciones de la diferencia entre los problemas actuales y los casos de
adaptación. Una vez el operador confirma la adaptación esta será insertada en la base de casos.
2.4 Retain (Recordar)
Una de las principales características de un sistema CBR es poder recordar los nuevos casos y su
solución aplicada, para ello es fundamental poder retener estos casos en lo que se llama la base
24
Estudio para la implementación de un sistema de razonamiento basado en casos
de casos. Esta cada vez irá aumentando y enriqueciéndose gracias a las soluciones de problemas
basados en la experiencia. La forma de estructuración de la base de casos y las políticas de
retención que el sistema CBR facilitaran el buen funcionamiento. Por ello el primer problema
que debe tratar un sistema de aprendizaje es decidir que casos se aprenden. La eficiencia de un
sistema CBR se puede degradar cuando el número de casos crece excesivamente y por tanto, se
debe evitar incluir casos que no aporten información nueva al sistema. El rango de posibilidades
va desde los sistemas que, de forma autónoma deciden que casos deben incluir hasta los que
delegan esta posibilidad en el mismo usuario.
El segundo problema relacionado con el aprendizaje es la que se refiere a la organización de la
estructura de casos. Dependiendo de la complejidad de la estructura utilizada, este proceso puede
ser más o menos complicado:
•
Si la organización es lineal, basta con añadir un nuevo elemento a la lista.
•
Si la estructura se induce a partir de los casos, será necesario redefinir la periódicamente la
estructura de indexación. Normalmente este proceso se realiza fuera de línea para no
perturbar la interacción del usuario con el sistema.
•
En los modelos más complejos donde se presentan generalizaciones de los casos, es
necesario aplicar, técnicas de aprendizaje más sofisticadas, similares a las aplicadas en otros
campos de inteligencia artificial
También se han realizado trabajos acerca del mantenimiento de la base de casos. Estas técnicas
permiten identificar casos poco utilizados y que por lo tanto puede interesar eliminar, así como
casos defectuosos o redundantes.
Tsatsoulis [33] propone una propuesta de utilizar CBR y aprendizaje y como los casos se van
expandiendo gracias al aprendizaje que el sistema realiza. Se nos presenta un sistema llamado
IDIOTS (Intelligent System for Design of Telecommunications Systems), el cual una vez tiene un
nuevo diseño ya ha sido revisado y aceptado por el sistema ha de ser recordado por el sistema.
Para este cometido han diseñado un sistema dinámico y que puede automáticamente expandir el
conociendo aprendido de las experiencias. El proceso es tan simple como tan solo añadir el
nuevo caso en la memoria dinámica, ya que la implementación del sistema está basada en la
teoría de Conceptual Clustering[34]. Esta metodología proporciona una organización del grupo
de casos que son conceptualmente relacionados, así por tanto los casos quedan almacenados en
varios niveles de abstracción y al mismo tiempo el conociendo queda organizado para su rápida
recuperación.
25
Estudio para la implementación de un sistema de razonamiento basado en casos
4. CBR CON OTRAS TÉCNICAS
CBR se ha combinado con otras técnicas de Inteligencia Artificial para la resolución de
problemas, dando así lugar a sistemas híbridos de razonamiento. Un sistema híbrido de
Inteligencia Artificial está formado por la integración de varios subsistemas inteligentes, cada
uno de los cuales mantiene su propio lenguaje de representación y un mecanismo diferente de
inferir soluciones. El objetivo de los sistemas híbridos es mejorar la eficiencia y la potencia de
razonamiento así como la expresión de los sistemas inteligentes aislados. En general la
investigación en el campo de los sistemas híbridos trata de mejorar la forma de desarrollar
sistemas y construir mecanismos más potentes, utilizando menos esfuerzo que el necesario para
generar un sistema basado en un solo sistema inteligente.
Los sistemas híbridos tienen potencial para resolver algunos problemas que son muy difíciles de
afrontar utilizando un único método de razonamiento. Por ello en este apartado se presenta la
utilización de un sistema basado en el razonamiento basado en casos con otras técnicas aplicadas
conjuntamente.
4.1 CBR Y RBS (Rule-based systems)
Los sistemas basados en reglas (rule-based systems - RBS-) son programas diseñados para
actuar como un experto humano en un dominio o área de conociendo particular, para ello aplican
técnicas de inteligencia artificial y su función es aportar soluciones a problemas y/o también
nuevo conocimiento. Los RBS disponen de una base de conocimientos (reglas) y una base de
hechos (datos relevantes relativos al problema), gracias al motor de inferencia que disponen
obtienen conocimiento nuevo a partir del existente. La inferencia puede ser de tres tipos:
deducción, es decir aplicando lógica de inferencia, inducción
donde se generalizan
observaciones para sintetizar conocimiento de más alto nivel y finalmente abducción,
razonamiento por explicación posible.
Los sistemas basados en reglas usan el “modus ponens”, es decir, si A es un hecho cierto y la
implicación A B es cierta, entonces se deriva que el hecho B es cierto. Así pues usando
técnicas de búsqueda mas comparación de patrones, los sistemas basados en reglas automatizan
métodos de razonamiento, que son progresiones de conjuntos de datos de partida hacia una
solución o conclusión.
26
Estudio para la implementación de un sistema de razonamiento basado en casos
A continuación se presentan tres artículos en los que se aplicó satisfactoriamente un RBS junto
con CBR y como dicha unión mejoró y/o ayudó en el proceso de gestión y administración del
conocimiento.
Montani y Bellazzi [35] del Departamento de Informática y Sistemas de la Universidad de Di
Pavia en Italia presentan una herramienta que aprovecha las capacidades de CBR y RBS. Se trata
de una herramienta Web para el tratamiento y decisión de pacientes que sufren Diabetes del tipo
I (IDDM), la cual es una de las mayores enfermedades crónicas en los territorios
industrializados. Para combatir la Diabetes tipo I, los pacientes necesitan inyecciones de insulina
cada cierto periodo para regular el metabolismo de la glucosa en la sangre.
Un caso de CBR es creado durante la visita periódica concretada del médico, el caso está
definido por una colección pares valor, es decir, solución – resultado. La solución es el protocolo
terapéutico asignado por el médico después de la revisión, y el resultado es el número de
episodios hypoglycemicos que sufrió el paciente al realizar dicho protocolo. Por otra parte estos
resultados son integrados en el sistema de razonamiento basado en reglas, el cual es capaz de
identificar si un paciente padece problemas de hipoglucemia o hyperglicemia, puede presentar
un listado con las sugerencias del problema y con su tratamiento de insulina, dieta e incluso
ejercicio físico recomendado. El hecho que la aplicación resida vía Web, permite al paciente
desde su propia casa ver la evolución de su historial, la insulina y los ejercicios que ha de
realizar. En cambio al médico es una herramienta para ayuda a la toma de decisiones.
Gómez et. al. [36] de la Universidad de Vigo y de la Universidad de Salamanca presentan un
trabajo sobre el estudio de aplicar las técnicas de CBR y RBS conjuntamente. Mas
concretamente el propósito del trabajo es la automatización de la tercera fase del ciclo CBR
llamada revisión, en la cual se comprueba si es correcta la solución propuesta para después ser
almacenada en la base de casos. Dicha automatización la realiza un RBS, con lo cual el
programa gana autonomía y precisión ya que no es un experto humano el que ha de decidir si la
solución es correcta.
Cuando se dispone un nuevo problema este, como en todo ciclo CBR, pasa a ser comparado con
los casos de la base de casos, para extraer aquellos casos más parecidos al caso inicial,
posteriormente el caso es adaptado para que la solución sea idónea al problema planteado y
posteriormente pasa a la fase de revisión en la cual el RBS aplica las reglas que dispone y decide
si la adaptación es correcta, si lo es se guarda en la base de casos, pero si la adaptación ha sido
incorrecta vuelve a esta fase para que sea aplicada otro tipo de adaptación al problema. De esta
27
Estudio para la implementación de un sistema de razonamiento basado en casos
forma se gana confidencialidad en el sistema y precisión a la hora de decidir que casos son los
que finalmente se guardan en la base de casos.
Golding [37] presenta una arquitectura para mejorar la precisión de un sistema basado en reglas
a través de un sistema de razonamiento basado en casos. La idea central es usar las reglas para
generar respuestas aproximadas a los problemas, y usar los casos para controlar las excepciones
de las reglas. De esta forma, se proporciona de una manera de mejorar una colección de reglas
con poco conocimiento. La arquitectura en cuestión ha sido aplicada a una aplicación de
pronunciación de nombres y es estructurada como un método y una colección de módulos de
soporte. El método núcleo es la parte que resuelve problemas, y este, incorpora dos ideas clave:
indexamiento basado en predicción, siendo una manera de indexar los casos para hacerlos más
accesibles, y en segundo lugar es necesario un predicado, que combina el resultado de RBS y
CBR. El papel de los módulos es convertir el conocimiento de entrada en una manera de poder
ser usado directamente con el método núcleo. Existen tres módulos de soporte: rational
reconstruction, theory extension, y threshold setting. El primero de ellos infiere el camino de la
solución para cada caso de la librería de casos. Ttheory extension sugiere suplementos a la reglas
de estructura para cubrir los perceptibles huecos en las reglas. Y en último lugar threshold
setting usa un procedimiento de aprendizaje para escoger valores para una colección de puntos
de partida que serán usados por el método núcleo
El sistema de pronunciación de nombres llamado Anapron, compuesto de una librería de unos
cinco mil casos, resuelve notablemente tarea de pronunciación de nombres poco frecuentes
gracias al uso de ondas comunes.
4.2 CBR y MBR (Model-based Reasoning)
MBR (Model-based Reasoning), al igual que CBR son técnicas de razonamiento de
conocimiento de dominio general, contrario a RBS que es aplicado a un dominio en particular.
Los procesos de razonamiento basado en modelos pueden ser vistos como procesos simbólicos
de una representación explicita de la mecánica interna de un sistema, con el fin de predecir,
simular e interpretar el comportamiento/reacción del sistema. Como regla general, un sistema de
razonamiento basado en modelos concentra el razonamiento sobre el comportamiento/reacción
del sistema desde un modelo explicito del mecanismo por modelación de dicho
comportamiento/reacción.
28
Estudio para la implementación de un sistema de razonamiento basado en casos
MBR es una de las técnicas básicas de adquisición de conocimiento más usadas por los
humanos. El ser humano aprende progresivamente gracias a que aplica sus modelos sobre la
realidad, es decir memoriza e imagina un modelo aproximado sobre la realidad y gracias a sus
experiencias pasadas, pueden responder a nuevos problemas. Así pues podemos ver todo este
proceso como una técnica MBR mas CBR.
Las técnicas MBR pueden representar muy concisamente el conocimiento de manera mas
completa y a mejor nivel de detalle que las otras dos técnicas de retención del conocimiento
(CBR y RBS). A continuación se presentan artículos donde se ha hecho uso de estas dos técnicas
integradas, incrementando notablemente la calidad del conocimiento.
Mérida et. al [38] proponen la integración de las estrategias de razonamiento basado en casos y
razonamiento basado en modelos para el diseño y desarrollo de RIMSAT (Remote Intelligent
Management Support and Training). La Comisión Europea financió el diseño del proyecto para
proveer de conocimiento basado en soluciones con el objetivo de garantizar la calidad de las
decisiones críticas, garantizar la seguridad y mejorar las competencias y responsabilidades de los
individuos y complejas organizaciones, es decir con el objetivo de prevención de riesgos y
catástrofes.
Gracias al uso combinado de MBR con soporte de CBR, RIMSAT puede proveer de una guía al
usuario para la ayuda en la elección de la solución más rápida y de más bajo coste posible. La
guía muestra los riesgos, el tiempo requerido y el coste de las soluciones aplicadas, para lograr
un buen enfoque entendible para el usuario en cuestión. De igual modo el sistema con la ayuda
combinada de las dos técnicas es capaz de justificar los resultados anteriores, de esta forma se
garantiza la calidad del resultado en cuestión. Los casos extraídos (utilizando CBR) se pueden
adaptar gracias a la ayuda del MBR, consiguiendo de dicha forma un nuevo caso para su
integración en el sistema.
El uso combinado de las dos técnicas es bastante beneficioso, pero RIMSAT principalmente
utiliza MBR. MBR se utiliza en la manipulación de casos (corrección, clasificación, etc.), para la
predicción temporal de la situación actual, para la revisión de todas las soluciones alternativas y
para refinar la solución extraída.
29
Estudio para la implementación de un sistema de razonamiento basado en casos
Bruninghaus y Ashley [39] de la Universidad de Pittsburg, presentan un algoritmo llamado IBP
(Iterative Belief Propagation), el cual combina razonamiento basado en casos y razonamiento
basado en modelos para una aplicación que interpreta y predice casos legales.
IBP interpreta la situación del caso legal, para llevar a cabo dicha interpretación, el algoritmo
identifica problemas y cuestiones del caso a tratar, usando para ello un modelo de dominio y
conocimiento sobre estos problemas y cuestiones. Posteriormente para cada problema y cuestión
identificado IBP determina lo bueno y lo malo que se puede extraer, es decir, el conocimiento
sobre los dos aspectos. Para lograr esto dispone del razonamiento basado en casos, es decir CBR
resuelve el conflicto de los problemas y cuestiones que IBP identifica. En último lugar IPB
combina este análisis con modelos de dominio para así poder crear la predicción sobre el caso.
Branting et. al. [40] han creado una técnica basada en MBR llamada model-based adaptation,
para ser integrada en un sistema CBR capaz de predecir el comportamiento de un sistema
biológico. Esta propuesta ha sido implementada en CARMA, un sistema para el manejo y
monitorización del consumo de forraje en una pradera a causa de los saltamontes. Los expertos
humanos guardan las experiencias de campo en forma de casos para su posterior inserción en el
sistema y crean modelos de análisis y predicciones sobre sus observaciones para conseguir que
la fase de adaptación se vuelva más precisa.
Para la fase de adaptación, CARMA utiliza tres subfases de la técnica model-based adaptation.
Estas subfases son: temporal project, feature adaptation, and critical period adaptation. La
primera de ellas hace referencia a que los casos hacen referencia a un momento y lugar concreto,
los casos están muy limitados por falta de información. Por ello hace falta un planteamiento más
general para simular el comportamiento y entender la situación de la población. En la segunda
fase las características de conducta son adaptadas y aproximadas mediante funciones que tienen
en cuenta tanto el tiempo de vida como el total de área infectada. La última fase es sólo si la
consumición de forraje de la pradera se da en época de crecimiento.
Gracias a su entorno de ventanas para la comodidad del usuario, CARMA ofrece explicaciones
del comportamiento biológico de una zona, así como las estimaciones de perdida de forraje,
migraciones de saltamontes y factores perjudiciales al paso del tiempo.
30
Estudio para la implementación de un sistema de razonamiento basado en casos
4.3 CBR y Lógica Difusa (Fuzzy Logic)
Las lógicas difusas son esencialmente lógicas multivaluadas que extienden las lógicas clásicas.
Las lógicas difusas procuran crear aproximaciones matemáticas en la resolución de ciertos tipos
de problemas. Pretenden producir resultados exactos a partir de datos imprecisos. El adjetivo
“difuso” aplicado a ellas se debe a que los valores de verdad utilizados en ellas tienen, por lo
general, una connotación de incertidumbre. Lo difuso puede entenderse como la posibilidad de
asignar más valores a los enunciados que los clásicos “falso” o “verdadero”. Así pues las lógicas
difusas son tipos especiales de lógicas multivaluadas.
El objetivo de todo sistema manejador de una lógica difusa es describir los grados de los
enunciados de salida en términos de los de entrada. Más aún, algunos sistemas son capaces de
refinar los grados de veracidad de los enunciados de salida conforme se refinan los de los de
entrada.
Las lógicas difusas han dado origen a sistemas expertos de tipo difuso y a sistemas de control
automático. Entre ellos, son de nuestro interés los que integran CBR. A continuación se
presentan tres artículos en los se aplicó CBR y lógica difusa.
Hansen et al. [41] proponen una aplicación llamada WIND-1 que combina razonamiento basado
en casos y metodología de lógica difusa para la predicción meteorológica. En concreto la
metodología ha sido integrada en el algoritmo k nearest neighbors para la recuperación de los
casos más similares. Los autores llaman a este método fuzzy k-nn y según ellos el sistema es
capaz de predecir con bastante exactitud el tiempo en las seis horas siguientes a su puesta en
funcionamiento. Para ello el sistema cuenta con una base de casos compuesta de 300.000 horas
de observación de un aeropuerto, es decir unos 36 años de experiencia.
Fuzzy K-nn utiliza varias medidas de similitud para encontrar los grados de similitud (cercano,
muy cercano, un poco cercano, etc.) entre los casos de la librería. Si se produce contradicción
entre los casos, el sistema utilizara estadísticas meteorológicas para obtener su predicción. Una
vez recuperado los casos, se crea un esquema para mostrar una predicción lo más exacta posible
del tiempo en las próximas horas.
31
Estudio para la implementación de un sistema de razonamiento basado en casos
Corchado et al. [42] presentan un método combinado de lógica difusa y CBR para la predicción
biológica del agua. Mediante lógica difusa se automatiza la etapa de revisión del sistema de
razonamiento basado en casos; asimismo ayuda en el proceso de obtención de la solución más
precisa. El sistema en cuestión ayuda a medir los niveles de concentración de di-átomos y
microorganismos existentes en las diferentes masas de agua.
La metodología propuesta deriva de la extensión del modelo de Takagi Sugeno Kang (TSK
Fuzzy) [43], pero incrementa considerablemente la capacidad de respuesta del sistema antecesor.
El motivo principal de esta mejora es que el nuevo método generaliza diversas características de
comparación y elimina ambigüedades que el anterior sistema cometía. En el proceso de revisión,
el sistema de lógica difusa es capaz de calcular un porcentaje de error mediante la utilización de
un vector de atributos (temperatura, PH, oxigeno, y otras características de las masas de agua),
que se encuentra asociado a todos los casos. Gracias a dicho vector el método difuso identifica
errores y estados erróneos que serían difícilmente localizables por un experto humano. El
sistema queda automatizado y con ello gana eficacia y precisión tanto en sus soluciones como en
la incorporación de los casos nuevos a la librería.
Bandini et al. [44] presentan una propuesta de fusión entre las técnicas de fuzzy logic y CBR
para su integración en el proyecto P-RACE. Las técnicas ayudan al soporte técnico para la toma
de decisiones a la hora de escoger los componentes y el dibujo que ha de tener la goma de la
rueda del vehículo de carreras, pues las condiciones climatológicas, los componentes químicos,
el calor en el asfalto, estabilidad, resistencia y otros factores a tener en cuenta pueden determinar
la victoria durante una carrera.
La propuesta captura el episodio que más se ajusta a la situación actual. Para ello se dispone de
una base de casos de la experiencia recogida de las observaciones realizadas por expertos
técnicos durante los entrenamientos y las competiciones oficiales. La técnica fuzzy logic es
utilizada para dicha recuperación de los casos más similares de la base de casos del sistema
CBR. El concepto de difuso es especialmente importante en este dominio ya que se ha de tener
en cuenta a la hora de recuperar los casos el estado del circuito, si esta mojado (bajo, medio,
alto), si esta seco (bajo, medio, alto), incluso otros factores como son la dificultad de la pista, su
temperatura, el número de curvas y por supuesto las condiciones climatológicas. Con la
obtención de todos estos parámetros se obtiene los casos más similares de la base de casos. En
caso necesario el caso recuperado más parecido sería adaptado a la nueva situación e
incorporado la base de casos para su futura consulta.
32
Estudio para la implementación de un sistema de razonamiento basado en casos
El sistema P-RACE es utilizado por el departamento Motorsports de la compañía Pirelli para el
reuso de las experiencias adquiridas en las carreras. El sistema consta de otras partes como por
ejemplo una base de datos sobre las actividades de las competiciones (fecha, vehículo, tiempos
etc.). P-RACE incrementa la calidad de las decisiones y la precisión de la carrera gracias al
conocimiento adquirido durante las competiciones.
4.4 CBR y algoritmos genéticos
Los algoritmos genéticos son métodos sistemáticos para la resolución de problemas de búsqueda
y optimización que aplican a estos los mismos métodos de la evolución biológica: selección
basada en la población, reproducción sexual y mutación. El problema a resolver se parametriza
en una serie de variables y se codifican en un cromosoma, sobre los cuales actúa el algoritmo
genético mediante las operaciones crossover y mutation. En el algoritmo genético va implícito el
método para resolver el problema. Hay que tener en cuenta que un algoritmo genético es
independiente del problema, lo cual lo hace un algoritmo robusto, por ser útil para cualquier
problema, pero a la vez débil, pues no está especializado en ninguno. Un algoritmo genético
optimiza sólo una función, no diversas funciones relacionadas entre sí simultáneamente. Por lo
tanto, un algoritmo genético consiste en lo siguiente: hallar de qué parámetros depende el
problema, codificarlos en un cromosoma, y se aplican los métodos de la evolución: selección y
reproducción con intercambio de información (crossover) y alteraciones que generan diversidad
(mutation). La aplicación de la unión de estas dos técnicas y su beneficio en la adquisición del
conocimiento se puede ver a gracias a los artículos presentados a continuación:
Como se mencionó anteriormente en el apartado 3.2 Reuse, Maher y Gómez de Silva [27] de la
Universidad de Sydney presentan una propuesta para el empleo de algoritmos genéticos en
combinación con un sistema de razonamiento basado en casos concretamente se utilizan los
algoritmos genéticos para la adaptación de la solución al nuevo problema.
Como podemos ver en este sencillo esquema de la Figura 7, se comienza con la especificación
de un nuevo problema, este se compara con la base de casos para recuperar los casos que más se
le parezcan, y a la hora de adaptar la solución se utiliza un algoritmo genético. Para ello se
establecen tres nociones fundamentales que son el genotype, el cual es una manera de representar
o codificar la información la cual será utilizada para producir el phenotype, que será la solución,
y por último el concepto survival of the fittest, que determina que genotype sobrevive para
reproducirse.
33
Estudio para la implementación de un sistema de razonamiento basado en casos
Figura 7. Ciclo CBR empleado por Maher y Gómez de Silva [15]
Así pues abra selección y reproducción de genotypes con intercambio de información y
alteraciones que generan diversidad, es decir mutaciones que generan diversidad de la
información, sino siempre se utilizaría la misma información. Si después de aplicarse este ciclo
de vida no se encontrara la solución el algoritmo genético volverá a aplicar otro ciclo completo
de vida. Ya que el material genético (información) es entregado a la siguiente generación. Una
vez se ha dado con la solución correcta al problema, se representa la información de la solución
en forma de caso y este queda representado en la base de casos
Khoshgoftaar et al. [45] presentan una herramienta llamada CBR GA-Optimizer que combina
algoritmos genéticos y CBR para mejorar el orden de módulos de software según su calidad. La
calidad se mide según el número de fallos con base en un conjunto de métricas de procesos y
productos. El orden relativo de los módulos se predice mediante MOM(s) (Module-Order
Model).
El algoritmo genético comienza con una colección de soluciones en la cual mecanismos de
evolución para obtener la mejor solución. Dicha población inicial genera otra secuencia de
poblaciones usando tres tipos de operaciones, crossover, mutation, y reproduction. Los
elementos de la población son llamados cromosomas y cada cromosoma, consistente en una
colección de genes, es caracterizado y medido por una función de refinamiento. Para cada
generación el algoritmo utiliza las tres operaciones antes comentadas para llegar a la solución
más óptima y precisa. CBR GA-Optimizer consta de dos mecanismos esenciales para su
funcionamiento. El mecanismo de algoritmos genéticos crea la población de cromosomas, y
envía a cada cromosoma al solucionador CBR, el segundo mecanismo, el cual lo evalúa y
reenvía la solución al algoritmo genético para su tratamiento correspondiente.
34
Estudio para la implementación de un sistema de razonamiento basado en casos
Louis et al. [46] describen un sistema de dominio general para la explicación de soluciones
generadas a través de la utilización de algoritmos genéticos en hibridación con sistemas basados
en el razonamiento. Los autores aplican CBR con algoritmos genéticos para obtener un análisis
sobre el historial de la búsqueda que dio como resultado la solución final. En términos de
genética, el genotype será utilizado como individuo que transporta su información a otros
individuos por reproducción, causando con ello el intercambio y mutación de la información.
Los individuos mejor adaptados transmitirán su información a la siguiente generación.
El sistema CBR crea un caso para cada individuo que el algoritmo genético ha evaluado. Esos
casos son indexados dependiendo de su eficacia y similitud sintáctica. Para este fin, el sistema
utiliza la construcción de bloques de hipótesis (BBH – building block hypothesis), estos bloques
son sub-soluciones que utilizan las métricas generadas por el algoritmo genético para indexar el
caso. Una vez el caso está adecuadamente formado y analizado, este puede contribuir a la
comprensión de la solución. Al término de la ejecución del algoritmo genético, el caso base que
se ofrece como solución, permite su interpretación y también su posible adaptación si fuera
necesaria.
4.5 CBR y ANN (Artificial Neural Networks)
Las redes neurales artificiales (ANN), son algoritmos implementados en forma de programas o
modelos electrónicos influenciados por el funcionamiento del cerebro humano. Las redes
neuronales tratan de imitar el proceso de almacenar información en patrones y utilizarlos para
resolver problemas con ellos. Con ello intentan reproducir el comportamiento humano mediante
ordenadores.
Figura 8 : Estructura de una ANN
La Figura 8 muestra el esquema de una red neuronal. Una red neuronal puede verse como un
conjunto de neuronas interconectadas, de tal forma que la salida de una neurona cualquiera, sirve
generalmente como entrada de otras neuronas. En este diagrama se representan las neuronas
como círculos. Algunas de ellas interaccionan con el medio para recibir las entradas. Las
35
Estudio para la implementación de un sistema de razonamiento basado en casos
neuronas de la capa de salida generan los valores que la red cree que corresponden con los
valores de entrada a la red. El número de neuronas, la disposición de las mismas y las
conexiones entre ellas determinan su componente estructural (arquitectura o topología). Este
define las rutas a través de las cuales se propagan las señales cuando se procesa información. La
principal propiedad de una red neuronal es la capacidad de aprender del entorno en el que opera
y mejorar su funcionamiento. Así, los parámetros de una red neuronal se adaptan como
consecuencia del proceso de estimulación originado por el entorno en el que opera.
A continuación se presentan algunos trabajos en los que se integran CBR y redes neuronales,
potenciando con ello la forma de resolver problemas que hubieran sido problemáticos al aplicar
un único método de razonamiento.
Martin et al. [47]
trabajaron en el desarrollo de STOY (Sistema de información para la
planificación del impacto del ruido en el ambiente), que tiene como finalidad monitorizar,
controlar y planificar la polución acústica proveniente de una Escuela de Artillería en Noruega.
El sistema, que implementa un sistema de CBR, utiliza una red neuronal como procesador para
el reconocimiento de las diferentes fuentes de ruido (conducción de tanques, fuertes disparos,
etc.) generadas en el entorno, que son medidas cada segundo por ocho estaciones
meteorológicas, para su posterior inclusión en la base de casos del CBR (indexando los nuevos
casos). Los autores aseguran que el porcentaje correcto de reconocimiento de fuentes de ruido
supera el 90%, mientras que los casos restantes (en los que no se ha podido identificar el origen
del ruido), son grabados para ser identificados manualmente por los expertos.
Corchado et al. [48] han desarrollado sistemas híbridos CBR/redes neuronales capaces de
predecir temperaturas oceanográficas de forma más acertada de lo que lo harían cualquiera de
los sistemas de razonamiento utilizados en el híbrido por sí mismos. En este caso se describe una
aplicación de Inteligencia Artificial para predecir la estructura de la temperatura del agua que se
produce a causa del moviendo de un buque.
La temperatura oceanográfica puede variar considerablemente según el lugar en lugar en el que
el buque se encuentre, ya que existen áreas en donde convergen diferentes masas aguas. Para
mantener esta información se utiliza una base de casos, creada con la información recogida de
travesías de buques e imágenes vía satélite. Los casos contienen la situación oceanográfica mas
un vector de temperaturas. En la extracción se utilizan diferentes métricas para determinar la
similitud entre el nuevo problema planteado y la librería de casos. Una vez recuperado el caso se
36
Estudio para la implementación de un sistema de razonamiento basado en casos
utiliza la habilidad de las redes neuronales para guiar la adaptación de los casos. La aplicación de
los dos sistemas hace que sea posible predecir en tiempo real la situación de la temperatura del
agua. El sistema fue probado en el océano Atlántico, en diferentes regiones y a diferentes
kilómetros recorridos, consiguiendo buenos resultados, ya que el sistema producía errores del
orden de 0.02ºC.
Sovat et al. [49] Proponen un mecanismo basado en las redes neuronales para la recuperación y
adaptación de los casos de un sistema CBR. La propuesta es de dominio general y según sus
autores mejora notablemente estas del ciclo CBR y como consecuencia aumenta la calidad de la
solución, ya que la intervención del experto humano no sería necesaria en la fase de adaptación.
La idea principal en la recuperación de un caso es la implementación una plantilla mediante
redes neuronales para obtener un método que identifique similitudes correctamente entre el
nuevo problema y los demás casos. Para ello, esta plantilla utiliza vectores de atributos que
pueden ser numéricos (enteros y reales), enumerados, listas, cadenas y boleanos. Las cadenas se
utilizan para representar información auxiliar y las listas pueden contener cualquier otro tipo de
atributos. Posteriormente este vector es normalizado y empleado para buscar similitudes. Para la
fase de adaptación de los casos recuperados se aplican dos pasos. El primero será realizado
exclusivamente por la red neuronal, para ello se añadirán o extraerán los atributos
correspondientes del problema a fin de configurar la adaptación, y también se incluirá cualquier
clase del proceso a fin de facilitar la integración con los otros casos de la librería. El segundo
paso, como adaptación final del caso, éste se lleva a cabo mediante reglas. Posteriormente el
caso es indexado en la base de casos para ser utilizado en caso necesario.
4.6 CBR y Ontologías
Como se ha dicho en anteriores ocasiones, cuando se dispone de un gran volumen de
información, esta tiene que estar clasificada y categorizada para poder ser extraída
eficientemente. Sin embargo, estos datos por sí solos, sin tener una semántica asociada, no
resultan de utilidad, ya que resultan ambiguos. Es por ello que se tiene que documentar estos
datos, para dotarlos de un significado. Es decir, se deben usar datos para describir los propios
datos, o lo que es lo mismo, metadatos. Las ontologías proporcionan maneras de clasificación de
la información y de los conceptos que en ella residen, maneras de clasificación de los metadatos.
37
Estudio para la implementación de un sistema de razonamiento basado en casos
La ontología se refiere a un conjunto de conceptos organizados jerárquicamente, se define como
el resultado de seleccionar un dominio y aplicar sobre el mismo un método para obtener una
representación formal de los conceptos que contiene y las relaciones que existen entre los
mismos. Esta metodología de jerarquización de la información es clasificada como si se utilizara
una metodología orientada a objetos, la cual permite aplicar conceptos como la herencia (padrehijo) y hacer razonamiento de conceptos. Esto es un factor fundamental en la clasificación de la
información.
A continuación se presentan dos artículos en los que se aplicó la técnica comentada
anteriormente junto con un sistema de razonamiento basado en casos.
Diaz-Agudo y Gonzalez [50] describen una propuesta CBR para la construcción de un sistema
que combine casos específicos de conocimiento y modelos de dominio de conocimiento general.
Describen CBROnto como una Ontología CBR que especifica una estructura modelada para
describir la reusabilidad CBR, es decir para describir métodos de solución de problemas basados
en tareas CBR que ellos solucionan. El trabajo que se realizó es el desarrollo de COLIBRI
(Cases and Ontology Libraries Integration for BuildingReasoning Infrastructures), un entorno
de ayuda durante el diseño del conocimiento CBR. El núcleo de la arquitectura de COLIBRI es
CBROnto, una Ontología que incorpora un CBR común.
CBROnto resuelve dos grandes problemas comunes cuando se aplican métodos para la solución
de problemas. El primero de ellos es debido al hecho de que los métodos para la solución de
problemas pueden usar una diferente terminología de la que se usa en el dominio. Para ello
CBROnto une esta brecha usando un mecanismo basado en descripciones lógicas (Description
Logics – DL’s). Las DL’s son comúnmente utilizadas por las Ontologías para formalizar
aspectos de la representación y de razonamiento, es decir capturan el significado de los datos
concentrándose en las entidades (agrupadas en conceptos) vinculadas por relaciones. El segundo
problema que resuelve CBROnto son los requerimientos de conocimiento requeridos por los
métodos para la solución de problemas. De nuevo las DL’s es el método utilizado para chequear
si los requerimientos de los métodos son satisfechos por el contexto de la aplicación, el cual esta
compuesto del conocimiento del dominio y de los casos base.
Ceccaroni de Laboratorios Fujitsu en cooperación con Cortés y Sánchez-Marré de la
Universidad Politécnica de Catalunya [51], han diseñado una arquitectura llamada OntoWEDSS.
La arquitectura es un sistema de ayuda a la toma de decisiones en el tratamiento de aguas
residuales. OntoWEDSS integra rule-based reasoning (RBR) y CBR (case-based reasoning), los
cuales incrementan considerablemente su potencial gracias al uso combinado con la ontología
38
Estudio para la implementación de un sistema de razonamiento basado en casos
que ellos especifican. La arquitectura de OntoWEDSS integra varios tipos de datos y unas
cuantas técnicas de AI (Artificial Intelligence), pero su tratamiento es bastante flexible. El
dominio es representado en detalle y se obtiene una explicación de la evolución de las
comunidades de microorganismos que el sistema detecte en la planta de tratamiento de agua, es
decir, gracias a OntoWEDSS es posible capturar, entender y describir el conocimiento adquirido
del entonto físico, químico y microbiológico existente en la planta de tratamiento.
OntoWEDSS incorpora una base de conocimiento microbiológico para los procesos de
razonamiento y representa relaciones causa-efecto. También hace uso de una Ontología para el
modelado del dominio y así poder clarificar la confusión de términos que podría producirse entre
ellos. Además es capaz de descubrir estados problemáticos en la planta y hacer uso de 2 sistemas
de razonamiento que son el RBR y el CBR, ellos supervisan la gestión de los procesos en 3
capas: percepción, diagnostico y soporte a la toma de decisiones.
Así pues, OntoWEDSS es un sistema para la ayuda a la toma de decisiones gracias a que es capaz
de señalar los posibles problemas de microorganismos, capaz de mostrar la situación de la planta
de agua y capaz de sugerir las mejores prevenciones para el manejo de ella.
39
Estudio para la implementación de un sistema de razonamiento basado en casos
5. MOTORES DE CBR
Respecto a los posibles dominios de desarrollo o circunstancias idóneas para la aplicación de un
sistema CBR, se deben tener en cuenta dos fuentes distintas de información. Por una parte
aquellos ámbitos en los que se ha dado una aplicación comercial real de CBR a la industria, y
por otro lado la larga lista de aplicaciones desarrolladas en entornos académicos para demostrar
la funcionalidad de CBR en dominios concretos de aplicación.
A continuación se presenta una breve descripción de los principales motores académicos y
comerciales de CBR.
5.1 Motores académicos
El aprendizaje basado en problemas, que surgió como técnica novedosa en la enseñanza superior
desde mediados de la década de los sesenta, se ha vuelto con el transcurso de los años en una de
las más prometedoras formas de acercamiento a la enseñanza, básicamente por promover
aspectos fundamentales en la optimización de la educación, como por ejemplo proveer de un
entorno en donde el estudiante está inmerso en actividades de la práctica cotidiana y en una
constante retroalimentación con los demás estudiantes. Otro aspecto es que el aprendizaje es
funcional, es decir, basado en la solución de un problema real y por ello se asegura la calidad de
la enseñanza. Pero se comprendió que este sistema de aprendizaje tenía mucho potencial para
quedarse estancado en el ámbito académico así que su paradigma se trasladó también a las
empresas.
Como se ha mencionado inicialmente las investigaciones sobre CBR se han realizado en las
universidades. Es así, que existen diversos proyectos desarrollados que implementan las
características más actualizadas de los sistemas CBR. A continuación se presenta una breve
descripción de los proyectos académicos más relevantes, de los cuales se instaló y ejecutó los
motores de Caspian, IUCBRF, Cbr-Shell y Selection Engine, de esta forma se estudió su
instalación, configuración y tratamiento de los casos de una forma más exhaustiva.
5.1.1 Caspian
CASPIAN [52], desarrollado en la Universidad de Gales, es una herramienta CBR de dominio
público, escrito en el lenguaje C que funciona bajo los sistemas MS-DOS y Macintosh. La
40
Estudio para la implementación de un sistema de razonamiento basado en casos
herramienta es de ámbito general y la representación de los casos es muy simple, es decir se
almacenan en un archivo ASCII.
La recuperación de los casos más similares se hace a través de del algoritmo Nearest Neighbor y
la adaptación de los casos se realiza mediante un conjunto de Reglas definidas también en un
archivo ASCII. Su interfaz es sencilla puesto que se emplea desde la línea de comandos del
sistema MS-DOS o Macintosh.
CASPIAN puede crear una base de casos de un archivo de casos escrito en el lenguaje CASL,
este es un lenguaje usado para los sistemas basados en el conocimiento. Para que CASPIAN
genere una base de datos se realiza a través del contenido de un archivo creado en CASL
conocido como Case File, CASPIAN utiliza dicho archivo para la base de casos en la memoria
de la computadora. Cuando un nuevo caso es añadido a la base de casos, este también es añadido
al final del archivo Case File.
Una vez creado el archivo Case File, se le da un nombre para guardarlo. Imaginemos que hemos
guardado casos de recetas de cocina en un fichero llamado Chef.
Para poder invocar a CASPIAN desde la línea de comandos haremos lo siguiente:
Caspian <filename>
Donde <filename> será el nombre del archivo que hemos creado en CASL. Al momento
CASPIAN realizará lo necesario para la creación de la base de casos en memoria y veremos por
pantalla estos pasos:
Reading case file…ok
Type checking…ok
Checking for doubly defined fields…ok
Checking for multiple fields…ok
Checking for doubly defined case names…ok
Checking for non-unique enumeration symbols…ok
Checking index block…ok
Checking modification rules…ok
Checking repair rules…ok
Building index structure…ok
41
Estudio para la implementación de un sistema de razonamiento basado en casos
Estas líneas nos indican que el archivo ha sido leído y que ha pasado satisfactoriamente todas las
pruebas. Una vez esto a pasado el sistema está preparado para los problemas que se le planteen
al sistema. El orden de ejecución en CASPIAN será el siguente:
1. El usuario introduce un caso para la comparación (the user case)
2. El programa efectúa una búsqueda indexada y encuentra una lista de los mas
parecidos según las restricciones del caso del usuario.
3. Si no se encuentran casos con las restricciones del caso del usuario, el sistema realiza
una indexación diferente sobre los valores para encontrar algún caso.
4. Un caso es seleccionado
5. La solución se repara si es necesario o no y se ofrece como resultado al usuario
Todos los errores que ocurren cuando se lee y se chequea el archivo con los casos base son
fatales y causan la salida del programa con el error code 1.
5.1.2 Selection Engine
Selection Engine [53] es un proyecto de código abierto desarrollado por Baylor Wetzel en el
2001. Esta implementado en Java y utiliza el algoritmo k-Nearest Neighbor para calcular la
similitud con los casos buscados. Este conjunto de librerías no está documentada por el autor,
pero este ha incluido algunos ejemplos de código con la distribución. Sus principales
características son:
1. Filtrado estándar de datos.
2. Similitud de instancias.
3. Tipos de datos por similitud.
4. Pesos
5. Búsqueda de atributos.
6. Fácil integración con otras aplicaciones
Por defecto, Selection Engine (SE) lee datos y metadatos de ficheros de texto y envía la
respuesta a la salida estándar. La clase principal se llama SimilarityEngine, esta utiliza las clases
de SimilarityCriteria, SimilarityWeights e Items. SimilarityCriteria representa los criterios de
similitud elegidos por el usuario, SimilarityWeights representa los pesos asignados por el
42
Estudio para la implementación de un sistema de razonamiento basado en casos
usuario a cada uno de los criterios de SimilarityCriteria; Items representa los casos fuente
extraídos de la base de casos.
Los tipos de datos que Selection Engine reconoce son: integer, floats, strings y valores boleanos.
Para valores numéricos reconoce dos valores especiales [MAX_VAL] y [MIN_VAL], que son
determinados para usarlos en los atributos de objetos Item.
En Selection Engine para la comparación y búsqueda entre el caso nuevo y todos los de la base
de casos se emplean atributos, valores y operadores. existen de 3 tipos de operadores:
1. ~
Significa “alrededor” y solo es utilizado en números.
2. % Significa “preferencia” y solo es utilizado en strings y boleanos.
3. !% Significa “exclusión” y solo es utilizado en strings y boleanos
Por ejemplo: “Edad ~ 37” (búsquedas realizadas alrededor de 37 años)
“Nombre % Manuel (búsquedas donde el nombre sea Manuel)
“Nombre !% Manuel (búsquedas que excluyan el nombre Manuel)
Existen operaciones relacionales usadas por la clase FilterEngine (=, !=, <, >, <=, >=) que se
utilizan para maximizar el filtrado de atributos numéricos. Por ejemplo, “Edad <30”, este filtrado
buscaría casos en que la edad fuera menor que treinta. Por defecto el peso de todos los atributos
es de 1, y este solo afecta a los operadores de similitud (~, %, !%).
El procedimiento de cálculo de similitud es el siguiente:
•
Calcular la distancia máxima de los n atributos.
•
Calcula las distancia entre el caso base y los casos fuente mediante el algoritmo Nearest
Neighbour.
•
Divide las distancias entre la distancia máxima encontrada (mediante normalización el
proceso)
•
Se crean porcentajes de similitud entre la distancia del caso base y los k vecinos (casos
fuentes) más próximos - k-Nearest Neighbour -.
43
Estudio para la implementación de un sistema de razonamiento basado en casos
5.1.3 NaCoDAE
NaCoDAE [54], Navy Conversational Decision Aids Environment ha sido desarrollado en el
Centro Naval de la Armada de los EEUU y ha sido aplicado a la investigación en el campo de la
Inteligencia Artificial. NaCoDAE es un prototipo desarrollado bajo el proyecto Practical
Advances in Case Based Reasoning, el cual tiene tareas de asistencia naval, y otras como la
ayuda a la toma de decisiones, mantenimiento, formación operacional, respuesta de crisis,
planificación, logística, diagnósticos de fallos, etc.
NaCoDAE está implementado en Java por lo que puede ser usado en cualquier computadora que
contenga la maquina virtual de Java, por lo tanto puede ser usado tanto en PCs Windows
95/98/NT, Sun Solaris y Macintosh como en plataformas Unix. Según sus características, sus
capacidades son:
•
Case Libraries: Crear, editar, cargar y guardar.
•
Browsing: Casos, descripciones de problemas y soluciones.
•
Problem Solving: Conductas iterativas o simuladas.
•
Parameter Settings: Cargar, editar Parámetros.
•
History: Colecciones automáticas de resultados de las sesiones de resolución de
problemas.
•
Library Revision: Se revisan automáticamente las librerías de casos.
Al descomprimir NaCoDAE en el directorio deseado encontraremos lo siguiente:
•
Una colección de *.class conteniendo la plataforma ejecutable independiente de Java.
•
Un fichero de Parámetros, con parámetros por defecto.
•
Directorio de Librerías, conteniendo la librería de casos.
•
Directorio Outputs, el directorio por defecto en el cual el sistema escribe los archivos de
salida.
•
Directorio Images, contiene los archivos de imagen de la aplicación.
Un caso en NaCoDAE esta definido por un nombre, un título, una descripción y la solución del
caso, el nombre del caso solo identifica al caso. El problema del caso es descrito textualmente y
dispone de una colección de pares pregunta-respuesta. Las preguntas están es formato texto, en
cambio las respuestas son del tipo binario (yes/no) o numéricas. Las soluciones son secuencias
de acción, donde son representadas por texto.
44
Estudio para la implementación de un sistema de razonamiento basado en casos
La propuesta de NaCoDAE para solucionar los problemas que se le plantean, es un visor del
programa llamado converser. El programa conduce a una serie de conversaciones interactivas
con el usuario, las cuales consisten en los siguientes pasos:
1. Una descripción parcial del problema.
2. Selección de las preguntas a contestar.
3. Contestando las preguntas seleccionadas.
4. Repetir los pasos previos o terminar la conversación.
Después de la conversación NaCoDAE mostrará una lista con los resultados de los casos más
similares.
Los parámetros de configuración general del programa son diversos y variados:
•
Silent: Si esta activo el usuario No visualizará todos los pasos del conversador del
programa a la hora de solucionar problemas, en cambio si no esta activo se podrán
visualizar todos los pasos.
•
Interactive: Este modo es solo relevante si el modo Silent esta inactivo. Si el modo
interactivo esta activo el usuario podrá conducir la conversación por donde a él le
parezca más relevante. Por el contrario, si está el modo inactivo la conversación será
conducida automáticamente por un simulador humano.
•
Debug Level: Controles de nivel de la depuración de la información.
•
Query Seeds: Cuando se utiliza el simulador humano se determina cuantas cuestiones
son automáticamente contestadas.
•
Similarity Metric: Determina que tipo de métrica de similitud será utilizada.
•
Max Queries: Cuando el modo Silent esta activo el parámetro seré el numero de casos
que manejará el simulador humano. Si el parámetro esta a 0 se miraran todos los casos.
5.1.4 IUCBRF
IUCBRF [55] ha sido desarrollado en la Universidad de Indiana para facilitar el desarrollo de los
sistemas basados en conocimiento. Ya que esta creado con Java puede ser usado en cualquier
ordenador que contenga la máquina virtual de Java.
IUCBRF tiene dos propuestas primarias:
45
Estudio para la implementación de un sistema de razonamiento basado en casos
1. Facilitar la reutilización del código
2. Servir como una herramienta pedagógica
Para la facilitación de la reutilización del código se ha de decir que con IUCBRF el diseño de los
nuevos sistemas CBR requieren menos reescritura del código común y los componentes pueden
ser intercambiados dentro y fuera del sistema. A más las ventajas de la reutilización del código
es beneficiaria en el ámbito educacional. Por ejemplo un sistema puede ser un lugar en el que los
estudiantes puedan implementar técnicas para la búsqueda de documentos sin necesidad de
preocuparse mucho sobre los detalles de la codificación.
IUCBRF puede ser aplicado a muchos dominios distintos, es decir mantiene la independencia del
dominio y de otros componentes. Existen tres maneras de indexación que son implementados en
IUCBRF. El primero y el más simple de los tres es la creación de la base de casos de manera
horizontal en que todos los casos son almacenados en una lista desordenada. La segunda forma
es almacenada en un archivo B-tree-backed. Y la tercera y última es en forma de d-tree, en el
cual los casos son agrupados de acuerdo con características comunes
El algoritmo de recuperación de casos de la base de casos que utiliza IUCBRF es k-nearest
neighbor (kNN), es decir los k casos con la descripción de un problema más cercana al problema
planteado, de acuerdo con el criterio de similitud, son recuperados.
Las propuestas de adaptación de IUCBRF son:
•
No adaptación
•
Porcentaje de pesos
•
Pesos máximos
La primera y más simple tipo de adaptación es la no adaptación, se devuelve la solución del
primer caso recuperado sin adaptar. La adaptación porcentaje de pesos, se asume la posibilidad
de la conversión de una solución a un doble valor. Dada una lista ordenada de casos recuperados
se devuelve el promedio del valor de la solución. Por último la adaptación pesos máximos,
también asume la posibilidad de la conversión de una solución a un doble valor, pero dada una
lista ordenada de casos recuperados se devuelve la solución que ha obtenido más valor.
IUCBRF cumple con las metas de independencia del dominio e independencia de otros
componentes JAVA. Esto beneficia a diseñadores de sistemas CBR de muchas maneras, por
ejemplo reduce el código que debería escribir un diseñador a la hora de construir un sistema
46
Estudio para la implementación de un sistema de razonamiento basado en casos
CBR. Así mismo, IUCBRF es muy extensible, cada paquete de componentes contiene una clase
de componente base con la cual se resume en general la funcionalidad requerida por cada clase
del tipo.
5.1.5 Cbr-Shell
CBR-Shell [56] ha sido desarrollado en el Artificial Intelligence Applications Institute (AIAI) de
la Escuela de Informáticos de la Univerdad de Edinmburgo. AIAI CBR Shell es una herramienta
que emplea algoritmos genéticos para el desarrollo de sistemas basados en casos.
CBR Shell se ejecuta mediante un applet java. Ha sido probado en Mozilla 1.2, en Linux,
Explorer 6.0, Windows XP y en Mac OS, con mínimamente la máquina virtual Java versión 1.4.
El núcleo del sistema ha sido aplicado con éxito a dominios muy difíciles de representar, como
detección de fraudes, diagnóstico de fallos en motores de aviones, valoración de riesgos de
enfermedades etc.
Respecto a los procesos CBR ofrece algoritmos de matching basados en lógica difusa,
algoritmos genéticos para aprendizaje de pesos, recuperación basada en el algoritmo nearest
neighbor y k-nearest neighbor, medidas de confianza adaptativas y algoritmos de diagnóstico
múltiple.
La herramienta realiza clasificación basada en la comparación de casos. Los parámetros de los
algoritmos pueden variar, por ejemplo:
•
El número de vecinos más próximos considerados pueden especificarse.
•
Los pesos (importancia) pueden establecer valores manualmente
•
Los pesos pueden optimizarse mediante algoritmos genéticos. La importancia del
algoritmo se mide mediante evaluación discriminatoria (leave-one-out).
5.2 Motores Comerciales
Los avances académicos más “maduros” se han implementado en herramientas comerciales. La
mayoría de estas herramientas se enfoca en la recuperación y retención de casos. Permiten al
usuario personalizar sus características según sus necesidades. Existen infinidad de herramientas
en el mercado, algunas de las más importantes se mencionan a continuación.
47
Estudio para la implementación de un sistema de razonamiento basado en casos
5.2.1 Kate
KATE [57] ha sido desarrollada por la empresa AcknoSoft y puede funcionar en entornos
Windows y Unix. El dominio de aplicación de esta herramienta son los sistemas inteligentes
para el soporte de decisiones. La representación de la base de casos se realiza a través de casos
jerarquizados.
KATE está en una suite formada por una serie de productos (KATE-editor, KATE CBR, KATE
Datamining, KATE Runtime). El motor KATE–CBR recupera casos mediante el algoritmo
nearest neighbor en el que la medida de similitud y los pesos relativos de los descriptores
pueden personalizarse para ajustarse a las necesidades de cada aplicación especifica. KATE hace
uso combinado de nearest neighbor con un proceso de inducción dinámica, en el que para cada
consulta se generan preguntas que se plantean al usuario, que permiten discriminar entre los
casos de la base de casos. Además KATE-Dataminig extrae conocimiento que está oculto en los
casos, construyendo automáticamente árboles de decisión a partir de los casos. Los árboles se
pueden usar para recuperar casos de manera muy eficiente, analizando los datos para extraer
reglas de decisión o estrategias de resolución de problemas, hasta llegar a las conclusiones o
diagnóstico.
Las herramientas de KATE Suite se usan en áreas muy diversas tales como la aerospacial,
automovilística, biología, defensa legal de clientes, etc. El uso de KATE Suite es especialmente
adecuado en el desarrollo de sistemas inteligentes para soporte de decisiones entre los que se
encuentran sistemas de diagnóstico, soporte técnico, mantenimiento y atención al cliente,
análisis de riesgos, estimación de costes, soporte de ventas y comercio electrónico.
5.2.2 CBR- Works
CBR-Works [58] desarrollado y distribuido por la empresa TecInno GMBH se diseñó como un
entorno de desarrollo completo de aplicaciones CBR, aunque también puede actuar para
desarrollar servidores CBR para varios clientes, ofreciendo soluciones configurables para
intranet, extranet e Internet. Escrito en Smalltalk, funciona bajo entornos de MS-Windows, Mac,
OS/2, UNIX.
CBR-Works es capaz de reutilizar datos disponibles en soporte electrónico (vía ODBC) y facilita
la importación desde los sistemas de bases de datos comunes, Además es compatible con todos
48
Estudio para la implementación de un sistema de razonamiento basado en casos
los sistemas operativos comunes y es fácil de integrar en aplicaciones ya existentes. En relación
a la representación de los casos de CBR-Works, este permite representar casos complejos y, por
tanto, diseñar aplicaciones en dominios estructurados. También ofrece medidas de similitud
predefinidas e incluye editores que permiten definir de manera intuitiva, medidas de similitud
complejas sobre los modelos orientados a objetos de conocimiento general sobre el dominio.
En las consultas y recuperación de casos CBR-Works ofrece varias interfaces, tanto en modo
consola como para clientes que lo usen como servidor. Además cubre todo el ciclo CBR, no solo
proporcionando mecanismos de recuperación (nearest neighbor), sino también la posibilidad de
revisar y aprender casos (experiencias). Respecto a la adaptación, sólo se permite mediante la
definición de reglas de adaptación por parte del diseñador del sistema CBR.
CBR Works resulta adecuado para el desarrollo de distintos tipos de aplicaciones CBR,
principalmente de comercio electrónico, de diagnóstico complejo, data mining, descubrimiento
de problemas, selección de productos, etc. Da sopote principalmente al desarrollo de sistemas de
clasificación y permite bases de casos grandes que gestiona de manera eficiente.
5.2.3 Orenge
Orenge [59] (Open Retrieval engine) es un marco de trabajo (con arquitectura modular) que
ofrece servicios en forma de componentes de software para desarrollar sistemas inteligentes de
búsqueda de información. Orenge representa una solución completa, independiente de la
plataforma, basada en componentes, para una gestión de conocimiento efectiva en e-business y
e-services. Además facilita su integración gracias a interfaces estándares como XML, ASP,
CORBA o JAVA, y conexiones ODBC-DB.
Orenge es muy flexible, adaptable y fácilmente integrable en arquitecturas cliente-servidor
existentes. El uso de Orenge se basa en configurar sus componentes, para resolver la tarea de
recuperación inteligente de información en un dominio determinado, la cual es su único objetivo.
Para ello, la arquitectura de Orenge se centra en knowledgeServer, que gestiona el conocimiento
de la aplicación y permite que los datos y documentos sean recuperados convenientemente e
eficientemente. Esta función de recuperación del conociendo se extiende con componentes que
gestionan perfiles de usuario, conexión con documentos y datos.
Las operaciones que son posibles realizar son tres tipos búsquedas (1) exactas, (2) basadas en
similitud y (3) lógica difusa. Estos datos y documentos son recuperados de manera eficiente e
49
Estudio para la implementación de un sistema de razonamiento basado en casos
inteligentemente. Además se permite formular consultas en distintos formatos (incluyendo
lenguaje natural) que son transformados a datos.
5.2.4 ReMind
ReMind [60] es una herramienta de Cognitive Systems Inc de dominio general para desarrollo de
sistemas CBR. Existen versiones para plataformas Macintosh, MS Windows y UNIX. Está
disponible como un conjuntos de librerías C para ser incluida en otras aplicaciones, y como
entorno completo de desarrollo interactivo de sistemas expertos basados en casos. ReMind ha
sido una herramienta muy influyente en otras herramientas CBR y actualmente todavía es una de
las más utilizadas.
ReMind permite importar casos de algunas bases de datos y no soporta representación
estructurada de casos, ya que aunque permite estructuras complejas, ya que no las utiliza durante
los procesos CBR. Además el proceso de inducción no trabaja correctamente con casos que
tengan muchos valores nulos.
Una de las características importantes de ReMind es que ofrece métodos distintos para la
recuperación de casos, por ejemplo, algoritmos nearest neighbor, inducción que construye
árboles de decisión en dos modos: simple o guiada por conocimiento y recuperación basada en
plantillas (es decir consultas tradicionales a bases de datos). No es posible combinar estos
métodos.
ReMind soporta adaptación usando formulas y permite aprendizaje de casos. Una característica
clave que posee frente a otras herramientas es su capacidad para utilizar conocimiento general
adquirido de expertos, para mejorar los procesos de indexación, recuperación y valoración de la
similitud entre casos y la adaptación. Además, después del proceso de recuperación, es capaz de
explicar por qué los casos han sido recuperados, esta explicación también indica cómo se pueden
adaptar estos casos.
5.2.5 ReCall
ReCall [61]es una herramienta desarrollada por Isoft. Esta ha sido codificada en C++ que ofrece
una combinación de recuperación de casos mediante el algoritmo nearest neighbor e inducción.
Está diseñada como una arquitectura abierta que permite añadir funcionalidad CBR a otras
50
Estudio para la implementación de un sistema de razonamiento basado en casos
aplicaciones. ReCall utiliza representación de casos orientada a objetos aprovechando
taxonomías, herencia, y relaciones entre objetos que permiten la representación del conocimiento
estructurado, casos incompletos, y conocimiento incierto. Además permite intercambio de
información con aplicaciones externas, en particular con bases de datos.
ReCall proporciona mecanismos de indexación jerárquicos que son utilizados para organizar la
base de casos y para recuperar casos de manera eficiente. Incluye distintos métodos para
analizar, organizar y seleccionar índices en una base de casos de manera automática basándose
en técnicas inductivas. Para usuarios avanzados se ofrece la posibilidad de imponer una
estructura en la organización de la base de casos.
El software de ReCall incluye editores gráficos especializados para definir objetos, relaciones
entre ellos, taxonomías y reglas de adaptación. Además su editor de árboles permite que el
usuario interactúe, controle y modifique la estructura de clasificación de casos creada con el
algoritmo inductivo.
Respecto a la recuperación de casos, se utiliza una variante del algoritmo nearest neighbor
mejorando así la similitud que tiene en cuenta tanto las propiedades y valores, como las
diferencias estructurales entre los casos. ReCall soporta un mecanismo de adaptación basado en
votaciones y el uso de reglas de adaptación definidas por el usuario. Además se pueden usar
llamadas externas a funciones (C++) para obtener procesos de adaptación más complejos.
5.2.6 ESTEEM
ESTEEM [62] desarrollado por Esteem Software Inc y que en la actualidad se encuentra en la
versión 1.4, es una herramienta desarrollada mediante el lenguaje Kappa-PC (paquete de
desarrollo de sistemas basados en conocimiento orientados a objetos en Windows). Es una
herramienta permite implementar reglas de adaptación.
ESTEEM soporta aplicaciones que acceden a múltiples bases de casos y una representación
compleja de casos mediante estructuras de casos anidadas (un caso puede ser parte de otro caso),
así mismo permite asociar información multimedia a otros casos. Para la recuperación de los
casos ESTEEM soporta varios métodos estándar de valoración de similitud (usando pesos en los
atributos, generación de vectores de pesos usando ID3). Además los usuarios pueden añadir
funciones de similitud propias.
51
Estudio para la implementación de un sistema de razonamiento basado en casos
ESTEEM combina un amplio rango de técnicas CBR con un entorno fácilmente extensible, estas
propiedades y las ya comentadas la hacen una herramienta adecuada para la enseñanza de CBR y
para explotar el potencial de CBR en una organización. ESTEEM se ha utilizado en el desarrollo
de aplicaciones para atención al cliente y diagnostico entre otras.
5.2.7 ART*Enterprise
La herramienta ART*Enterprise (Automated Reasoning Tool) [63] pertenece actualmente a la
empresa Brightware Inc. Su entorno es muy variado como ordenadores de escritorio y estaciones
de trabajo. Para la recuperación de casos utiliza el algoritmo nearest neighbor. Para la
adaptación de casos utiliza funciones y reglas y alguna técnica basada en conocimiento.
Esta es una herramienta integrada y orientada a objetos para el desarrollo de aplicaciones que
ofrece una gran variedad de paradigmas de representación y programación incluyendo un
lenguaje de programación procedural, objetos con soporte para herencia múltiple, encapsulación
y polimorfismo, reglas y mecanismos CBR. Así mismo, ofrece una amplia gama de alternativas
en estilos de programación.
El software ART*Enterprise incluye un generador de interfaces de usuario y además, facilita la
creación de módulos reutilizables. Facilita el uso de distintas fuentes de datos y el intercambio
de información con la mayoría de los formatos de bases de datos para el desarrollo de
aplicaciones cliente-servidor.
ART*Enterprise es muy manejable ya que los desarrolladores tienen acceso a toda la
funcionalidad del CBR. ART*Enterprise es especialmente adecuada para incluir funcionalidad
CBR en sistemas de información corporativos.
52
Estudio para la implementación de un sistema de razonamiento basado en casos
6. IMPLEMENTACIÓN DE MÓDULO GENÉRICO DE RECUPERACIÓN
En este apartado se describe la implementación de un modulo genérico de recuperación de casos,
realizado para demostrar la utilidad de los sistemas CBR. Para esto en primer lugar se describen
los proyectos sobre los cuales se ha basado la aplicación. Posteriormente se explica el desarrollo
y creación de CBR Extracción Module, se explica su mecánica y su entorno de ventanas, así
como sus características más importantes.
6.1 Descripción de las herramientas de software empleadas
Una de las partes más importantes en todo sistema CBR es la recuperación de los casos más
relevantes. Para ello cada sistema utiliza diferentes técnicas y metodologías con el objetivo de
obtener los casos de la manera más eficaz y rápida posible. Para poder entender en profundidad
este módulo de los sistemas CBR se ha escogido el motor de Selection Engine [53], el cual será
explicado en profundidad en los siguientes apartados.
6.1.1 The Selection Engine Project
A grandes rasgos la descripción de Selection Engine [53] se ha explicado en la Sección 5.1.2.
Ahora, basados en este motor, se realizará en primer lugar un estudio exhaustivo de su
utilización en la implementación de un módulo genérico de recuperación de casos. La
implementación original del motor no está documentada y su utilización es difícil. Además, los
tipos de datos definidos son simples lo que obliga a emplear descripciones simples de casos.
En segundo lugar para ilustrar más fácilmente la estructura de clases y funcionamiento de
Selection Engine se describirá la parte básica del motor teniendo en cuenta su estructura de
clases. Y finalmente se describirá la estructura del gestor general del motor relacionado los
módulos más importantes. Puesto que la documentación de Selection engine no esta realizada se
ha decido documentar el proyecto. La documentación detallada de cada clase se ha introducido
en el código fuente de las mismas. Está ha sido la aportación realizada al motor de Selection
Engine.
53
Estudio para la implementación de un sistema de razonamiento basado en casos
6.1.1.1 Motor de recuperación de Selection Engine
El algoritmo utilizado por Selection Engine en la recuperación de los casos es el llamado knearest neighbor, el cual es uno de los más utilizados por la gran mayoría de productos CBR.
Para poder explicar su funcionamiento se considerará como ejemplo un caso de dos atributos
iniciales, el rendimiento (performance), el cual su valor máximo será de 10 y el mínimo de 1, y
el precio (price) de un producto, con la misma escala de valores que el anterior atributo. El
espacio de casos será representado en forma de gráfico de dos dimensiones (figura 9), puesto que
se dispone de dos atributos. En el gráfico se han introducido cuatro casos más el caso base.
•
Caso A: Precio 4, rendimiento 4
•
Caso B: Precio 7, rendimiento 7
•
Caso C: Precio 10, rendimiento 9
•
Caso D: Precio 1, rendimiento 6
Caso Objetivo (target) : Precio 1, rendimiento 10
10
Target
Performance
C
8
B
6
D
4
A
2
0
0
2
4
6
Price
8
10
Figura 9
Ahora que se ha definido el espacio de casos mas el caso objetivo, se han de calcular el % de
similitud de los casos A, B, C, D con el caso objetivo. Para este fin se hace uso del famoso
teorema de Pitágoras ( a² + b² = c² ), gracias a Pitágoras se puede calcular los lados de un
triangulo. Si se observa el caso objetivo con el caso A se puede apreciar que el único lado que no
se conoce es el lado c, pues a es 6 ( 10-4 ) y b es 3 ( 4-1 ). Aplicando Pitágoras:
a² + b² = c²
6² + 3² = c²
36 + 9 = c²
c² = 45
c = 6.71
De esta forma sencilla se acaba de obtener la distancia entre el caso objetivo y el caso A. De una
forma más rápida se puede omitir pasos en el cálculo. Caso objetivo (10,1) – caso A (4,4) darían
como resultado las siguientes operaciones:
54
Estudio para la implementación de un sistema de razonamiento basado en casos
a²= 10-4 = 6
b²= 1-4 = -3
a² + b² = c²
6² + -3² = c²
36 + 9 = c²
c² = 45
c = 6.71
Aplicando la misma metodología en los casos B, C, D se obtiene que la distancia de B es 6.71, la
de C es 9.06 y por último la distancia de D es 4. Por lo tanto el caso D es quien tiene la distancia
más cercana al caso objetivo. Ahora para saber el % de similitud se ha de observar los rangos
máximos y mínimos de los atributos. Para el rendimiento el rango es de 1-10 y para el precio
también corresponde de 1-10. Aplicando nuevamente el teorema de Pitágoras (10,10) – (1,1)
para los atributos se obtiene:
a²= 10-1 = 9
b²= 10-1 = 9
a² + b² = c²
9² + 9² = c²
81 + 81 = c²
c² = 162
c = 12.73
Ahora obteniendo el resultado de la distancia del caso D dividido por el resultado de los rangos
máximos y mínimos, obtenemos que 4/12.73 es igual a 0.31, ahora 1-0.31 es igual a 0.69, que
multiplicado por 100 es 69. Por lo tanto el caso D tiene un 69 % de similitud con el caso
objetivo. Las similitudes con el caso A es de 47%, B 47 % y finalmente C con 29 %.
El caso anterior era extremadamente sencillo puesto que solo se disponía de dos atributos, a
continuación se explicará otro ejemplo más complicado en el que los casos están compuestos de
4 atributos. Los atributos en este nuevo caso constarán a mas de los dos anteriores (rendimiento
y precio), de otros dos llamados fiabilidad y tamaño, con el mismo rango que los otros atributos,
es decir de 1-10. En el nuevo ejemplo se desea encontrar un caso objetivo que tenga por
características precio 1, rendimiento10, fiabilidad 10 y tamaño 1, es decir (1, 10, 10, 1), y los
casos de que se dispone son:
•
Caso A: Precio 4, rendimiento 4 , fiabilidad 4, tamaño 4, es decir (4, 4, 4, 4)
•
Caso B: Precio 7, rendimiento 7, fiabilidad 2, tamaño 8, es decir (7, 7, 2, 8)
•
Caso C: Precio 10, rendimiento 9, fiabilidad 6, tamaño 10, es decir (10, 9, 6, 10)
•
Caso D: Precio 1, rendimiento 6, fiabilidad 8, tamaño 3, es decir (1, 6, 8, 3)
55
Estudio para la implementación de un sistema de razonamiento basado en casos
Ahora la distancia entre el caso objetivo y el caso A, es de:
(1,10,10,1) - (4,4,4,4) = -3, 6, 6, -3
a² + b² + c² + d² = e²
-3² + 6² + 6² + -3²= e²
9 + 36 + 36 + 9 = e²
e² = 90
e = 9.49
Aplicando nuevamente el teorema de Pitágoras (10, 10, 10, 10) – (1, 1, 1, 1) para los atributos se
obtiene 18. Por lo tanto y aplicando los cálculos se obtiene que el caso A dispone de un 47 % de
similitud con el caso objetivo. Ahora bien, Selection Engine aplica si se desea, una escala de
importancia sobre los atributos. Esta escala ofrece los pesos (importancia) en valores numéricos,
peso=5 (muy alto), peso=4 (alto), peso= 3 (intermedio), peso=2 (bajo), peso=1 (muy bajo). Para
ejemplificar los cambios se supondrá que el usuario ha elegido un peso de 5 para el precio, un
peso de 4 para el rendimiento, 2 para la fiabilidad y para el último atributo, el tamaño un peso de
1, es decir, (5, 4, 2, 1). Los cálculos ahora se realizaran de la siguiente manera:
Caso objetivo = (1,10,10,1) * (5,4,2,1) = (5,40,20,1)
Caso A = (4,4,4,4) * (5,4,2,1) = (20,16,8,4)
(5,40,20,1) - (20,16,8,4) = -15, 24, 12, -3
a² + b² + c² + d² = e²
-15² + 24² + 12² + -²= e²
225 + 576 + 144 + 9 = e²
e² = 954
e = 30.89
Ahora se calcula la distancia de los atributos usando los pesos:
Valor máximo = (10, 10, 10, 10) * (5, 4, 2, 1) = (50, 40, 20, 10)
Valor mínimo = (1, 1, 1, 1) * (5, 4, 2, 1) = (5, 4, 2, 1)
(50, 40, 20, 10) - (5, 4, 2, 1) = 45, 36, 18, 9
a² + b²+ c² + d² = e²
45² + 36² + 18² + 9² = e²
2025 + 1296 + 324 + 81 = e²
e² = 3726
e = 61.04
Finalmente se obtiene que la similitud del caso A (1-(30.89/61.04)) es igual a 49%. El algoritmo
k-nearest neighbor encontrará los k casos más similares de una base de casos, la variable k es
especificada por el programador, aun que en otros programas podrá ser definida por el usuario.
Esta es una diferencia esencial entre el algoritmo nearest neighbor, el cual devolverá todos los
casos.
56
Estudio para la implementación de un sistema de razonamiento basado en casos
6.1.1.2 Clases empleadas para definir y extraer casos
La clase principal de Selection Engine es la llamada SimilarityEngine, dicha clase es el motor de
inferencia CBR en el cual se calcula la similitud de una colección de casos respecto a un objetivo
concreto, es decir, según las preferencias de búsqueda previamente introducidas, la similitud
variará para obtener el caso más parecido de entre todos los casos. La similitud es calculada en
tanto por ciento, cuanto mayor sea la similitud de un caso mayor será su tanto por ciento.
SimilarityEngine hace uso de una gran cantidad de objetos, tal y como se puede ver en la figura
10
Figura 10. Clases relacionadas para definir un caso
Ítems es el objeto que contiene una colección de objetos Item. El objeto Item, es lo que
comúnmente se llama un caso de la base de casos. La base de casos es el conjunto de casos. Por
lo tanto, el objeto Ítems contiene los casos extraídos de la base de casos. Cada objeto Item posee
una colección de objeto Traits. El objeto Traits contiene a su vez una colección de objetos Trait.
Un objeto Trait es un atributo con su correspondiente valor, por ejemplo, si se dispone de una
base de casos de ordenadores donde cada caso se compone de los atributos propios de un
ordenador. Un Trait correspondería por ejemplo al atributo RAM y su valor 128. El objeto Traits
es el que contendría la colección de atributo/valor de los ordenadores para un caso.
En Selection Engine un Item es genérico y representa cualquier cosa, producto, canción,
decisión, ordenador, etc. Siguiendo con el ejemplo expuesto un objeto Item sería un caso
ordenador con sus atributos/valores. Ítems, correspondería a los casos extraídos de la base de
casos de todos los ordenadores.
57
Estudio para la implementación de un sistema de razonamiento basado en casos
Figura 11. Correspondencia de atributo/tipo de dato.
Como se puede ver en la figura 11, el objeto Item hace uso de un objeto llamado
TraitDescriptors el cual juega el papel de meta-dato, este contiene a su vez una colección de
objetos TraitDescriptor. Un objeto TraitDescriptor contiene pares atributo/tipo de dato, donde el
atributo es el nombre del atributo y el valor_tipo es el tipo de dato de dicho atributo. Siguiendo
con el ejemplo de los ordenadores, un traitDescriptor contendría el atributo RAM y el valor
Integer. El objeto TraitDescriptors es el que contendría la colección atributo/valor de los
ordenadores. A simple vista los objetos TraitDescriptor y Trait pueden parecer muy parecidos,
pero como se ha explicado y como su mismo nombre indica en uno se guarda el nombre y su
tipo de dato, mientras que en el otro se guarda el nombre y su valor.
Los objetos descritos hasta ahora (Items, Item, Traits, Trait, TraitDescriptors, y TraitDescriptor)
que existen en Selection Engine ayudan al tratamiento genérico de extracción de cualquier
información.
Similarity Engine hace uso de dos objetos para el cálculo de similitudes con la base de casos,
estos objetos son llamados SimilarityCriteria y SimilariWeights, tal y como se puede ver en la
Figura 12. El primero de ellos contiene una colección de objetos SimilarityCriterion. Un objeto
SimilarityCriterion describe una relación simple entre un atributo, un operador y un valor.
Selection Engine reconoce tres tipos de operadores especiales a parte de los relacionales (=, !=,
>, <, >=,<=). El operador ‘~’ para aquellos c atributos numéricos en las que se desea estén
alrededor de un valor. El operador ‘%’, para aquellos atributos en las que se desea preferencia
respecto al valor. Y finalmente el operador ‘!%’ que significa exclusión, es decir el no deseo de
dicho valor para el atributo. Además Selección Engine reconoce dos tipos de valores especiales,
[MAX_VAL] y [MIN_VAL] que son utilizados para obtener los valores máximos y mínimos
posibles de valores numéricos.
En el ejemplo de los ordenadores, un objeto SimilarityCriterion por ejemplo sería el compuesto
por el atributo marca, el operador ‘!%’ y el valor “Intel”. Por lo tanto se está dando un criterio de
58
Estudio para la implementación de un sistema de razonamiento basado en casos
búsqueda que especifica que no se desea la marca “Intel”. El conjunto de dichos criterios estaría
contenido en el objeto SimilarityCriteria. El segundo objeto del que hace uso para cálculo de
similitudes, es el llamado SimilarityWeights. Este objeto contiene una colección de objetos
SimilarityWeigh, este objeto contiene pares atributo/valor, donde el atributo es el nombre del
atributo y el valor es el peso que tiene dicho atributos. El peso puede ser cualquier entero, pero
es suficiente introduciendo un valor de 1 a 5.
Figura 12.Clases relacionadas para el cálculo de similitudes
Hasta ahora se ha descrito todo lo que utiliza la clase principal de Selection Engine, pero para
que dicha clase calcule las similitudes entre los casos de una base de casos, previamente se han
de cargar los casos. La base de casos puede estar contenida en ficheros de texto o en una base de
datos (p.ej. Oracle, mySQL, etc.). El método más sencillo, y empleado originalmente por el
autor, es emplear ficheros de texto. En el siguiente ejemplo se empleará el fichero “Data.txt”
(Figura 13). Los criterios de búsqueda pueden definirse estáticamente mediante ficheros de texto
o dinámicamente mediante interficies de usuario. El Ejemplo que emplea Selection Engine es el
más sencillo, mediante el fichero de texto “Query.txt”.
Un caso se representa por un conjunto de atributos relacionados entre sí con sus
correspondientes valores. Al crear una base de casos de ordenadores por ejemplo, el formato del
archivo “Data.txt” podría ser el siguiente:
59
Estudio para la implementación de un sistema de razonamiento basado en casos
f=s:marca
d=Lotus
d=Casio
d=Casio
d=Swatch
d= Gucci
d= Gucci
|s:modelo|i:coste|
|rp-320
|500
|f-91w
|6
|f-245g
|100
|qwe-56
|50
| ee -123 |600
| et -54 |1000
b:sumergible
|
y
|
n
|
y
|
n
|
y
|
y
Figura 13: Data.txt
El carácter ‘f’ es indicativo de que en esa línea se definirán las características del caso. Los tipos
de datos anteceden al nombre del atributo, por ejemplo, “s:marca” define que el atributo marca
es de tipo string. Lo mismo sucede para definir integer (“i”), boleano (“b”) y float (“f”). El
carácter ‘d’ es indicativo de que esa línea representa los valores de los atributos de un caso. Una
vez cargado el fichero, cada característica/valor corresponderá a un objeto Trait, el conjunto de
características/valor estará contenido en el objeto Traits y un Objeto Item contendrá un objeto
Traits. De igual forma, también se han creado objetos traitDescriptor, que contienen
característica/valor_tipo. El conjunto de objetos traitDescriptor estará contenido en el objeto
TraitDescriptors.
El segundo de los archivos, “Query.txt” (figura 14) corresponderá a los criterios de búsqueda
definidos. Según los criterios de búsqueda el tanto por ciento de similitud aumentará o
disminuirá. El formato del archivo podría el siguiente:
c
c
w
c
c
w
|
|
|
|
|
|
marca
marca
marca
coste
coste
coste
|
|
|
|
|
|
!% | Casio
!= | Gucci
2
<= | 50
~
| 30
4
Figura 14 : Quero.txt
El carácter ‘c’ o ‘w’ indica si se trata de un criterio de similitud o un peso. Una vez cargado el
archivo, cada criterio de similitud corresponderá a un objeto SimilarityCriterion, la colección de
todas las similitudes estarán guardadas en el objeto SimilarityCriteria. Por el contrario la
colección de pesos residirá en el objeto SimilariWeights.
60
Estudio para la implementación de un sistema de razonamiento basado en casos
6.1.1.3 Gestor general de clases
A continuación se explicará en funcionamiento del gestor general de los módulos de Selection
Engine y su interrelación con las diferentes clases para su correcto funcionamiento. Como se
puede ver en la Figura 15 la clase que gestiona todo el sistema Selection Engine es la llamada
MachingItemsManager. Esta clase hace uso del objeto ItemManager, el cual es el encargado de
leer el fichero Data.txt y así obtener los traitDescrptors y los Ítems.
Figura 15. Gestor de clases
MachingItemsManager utiliza el objeto QueryManager para la creación de filtros y similitudes.
Este crea a su vez un objeto QueryReader, el cual es el encargado directo de la creación de los
objetos FilterCriteria, SimilarityWeights y SimilarityCriteria. QueryReader leerá el fichero
Query.txt y clasificará su información según los operadores que lea, si lee los operadores
especiales "~", "%" y "!%" su información será clasificada en el objeto SimilarityCriteria. En
cambio los operadores relacionales (=, !=, >, <, >=,<=) son clasificados en el objeto
61
Estudio para la implementación de un sistema de razonamiento basado en casos
FilterCriteria. Y Por último aquellas características con peso serán clasificadas en
SimilarityWeights. Estos tres Objetos como se ha dicho anteriormente serán utilizados por el
motor para dar como solución los porcentajes de similitudes con el caso buscado.
El objeto FilterEngine es el encargado de filtrar aquellos casos que violen los criterios de
búsqueda definidos en el objeto FilterCriteria. Para ello se comprueba cada Item contenido en el
objeto Ítems y se devuelve una colección filtrada Ítems a la clase MachingItemsManager. Esta
nueva colección filtrada será utilizada por el motor, es decir por la clase SimilarityEngine.
Figura 16. Relaciones en el filtrado de casos
En la llamada al método principal de la clase SimilarityEngine, ComputesSimilarity(), se utilizan
los objetos Ítems (casos filtrados), SimilarityCriteria y SimilarityWeights, tal y como se puede
ver en la Figura 16. En dicho método es creado el objeto DataSetStatistics, el cual a su vez
contiene una colección de objetos TraitStatistics (Figura 17), Un objeto TraitStatistics guarda los
valores mínimos y máximos de las características de los Ítems. Para las características que no
sean ni enteras ni reales se introduce un valor máximo de 1 y mínimo de 0, en cambio para las
enteras y reales los valores máximos y mínimos corresponderán a los valores más elevados y
bajos de las características de entre todos los Ítems.
62
Estudio para la implementación de un sistema de razonamiento basado en casos
Figura 17. Clases involucradas en el filtrado de casos
En la llamada al método ComputesSimilarity() se construye también un objeto llamado
SimilarityCriterionScores, al cual es el encargado de guardar una colección de de objetos
SimilarityCriterionScore. En este último Objeto se guarda el valor normalizado, es decir, de cada
atributo se normaliza su valor para que disponga de un rango comprendido entre 0 y 1, donde 1
significaría que es el máximo valor en la colección y 0 significaría el mínimo. (Figura 17). Esta
es la arquitectura de clases que hace uso Selection Engine para gestionar y ofrecer a un usuario
los casos más similares de una base de casos.
6.1.2 Ozone DataBase
La base de datos utilizada en CBR Extracción Module para leer y almacenar los casos ha sido
Ozone [64]. Ozone es una base de datos orientada a Java y distribuida bajo licencia de código
abierto. El proyecto Ozone permite a los desarrolladores construir estructuras orientadas a
objetos para su integración en la base de datos. Ozone incluye un completo soporte para el
código XML (W3C-compliant), de esta manera un programador puede utilizar cualquier
herramienta XML para poder acceder a los datos almacenados.
Ozone esta basado en una arquitectura de activación general. Los objetos nunca se pierden del
servidor por ninguna razón, pues las aplicaciones cliente controlan sus objetos en la base de
datos mediante objetos Proxy. Ozone es más rentable en donde los datos son frecuentemente
modificados por los clientes. Ozone también dispone de soporte incluido para clases para
Apache Xerces-J y para Xalan-J. Existe la versión 1.2 de Ozone pero aun es una versión
experimental. La versión 1.1 incluye
•
Multi Usuario y soporte multi-thread
•
Acceso rápido a Objetos
•
Soporte JTA/XA
•
Reconociendo de deadlock
•
Soporte BLOB (para escribir datos de objeto binario grande)
63
Estudio para la implementación de un sistema de razonamiento basado en casos
•
Soporte XML (DOM)
•
Soporte ODMG 3.0
•
Reutilización de memoria no usada
Ozone guarda el administrador que accede a la base de datos, esta asociación la realiza
directamente desde el ordenador en que la base de datos es creada, y al cerrarla guarda el usuario
administrador para que nadie más pueda abrirla. Pero mediante configuración es posible declarar
que otros usuarios tengan acceso a ella. Para ello el usuario administrador debe ejecutarla
previamente y dar de alta a aquellos usuarios que el desee dispongan de acceso para manejar los
objetos creados en la base de datos.
La arquitectura de Ozone se puede ver a grades rasgos en la Figura 18, en la cual se puede
apreciar 4 capas :
Figura 18. Las cuatro capas de ozone
Client: Esta es el área de aplicación del cliente, el cliente obtiene una conexión al Servidor de
ozone, la conexión puede estar compartida por muchos threads. La aplicación del cliente
interactúa con la base de Datos API para crearla, borrarla y modificar objetos persistentes.
Network: La capa Network es donde el protocolo de ozone juega un papel similar a RMI
(Invocación Remota de Métodos), es decir, el sistema RMI de Java permite a un objeto que se
está ejecutando en una Máquina Virtual Java (VM) llamar a métodos de otro objeto que está en
otra VM diferente.
64
Estudio para la implementación de un sistema de razonamiento basado en casos
Server: El servidor gestiona las conexiones de clientes, la seguridad, transacciones y llegada de
invocaciones de métodos de clientes. El servidor mantiene una buena transaccionalidad para
múltiples clientes que deseen tener acceso.
Storage: la base de datos es siempre accesible en Ozone Server
Crear y/o abrir la base de datos se realizará mediante comandos de MS-DOS.
6.2 Desarrollo de la aplicación
En este último punto del proyecto se describirá el uso de la aplicación desarrollada en JAVA.
CBR Extraction Module, es un entorno gráfico genérico para la creación de un sistema de
razonamiento basado en casos, así como su propia utilización para la búsqueda de los casos más
similares. Gracias a las restricciones y preferencias que los usuarios deseen aplicar, el programa
utilizará el motor de Selection Engine para el filtrado de criterios. El sistema es totalmente
genérico, la única diferencia residirá en la base de casos. En la cual se almacenaran los casos del
entorno deseado por el usuario. Por lo tanto, el entorno dependerá de las necesidades del usuario
y una vez creado el entorno con los atributos necesarios para definirlo, se podrán introducir los
casos basados en experiencias. Dichos casos no solo podrían acaparar entornos tan importantes
como la predicción de tiempo, o la predicción médica de las enfermedades o dolencias de un
paciente, sino también es posible darle un enfoque para ayudar al cliente a la elección del
producto a su gusto. Es decir, ayudar en la compra-venta de ordenadores, juegos, móviles, e
incluso productos de alimentación u otros entornos en los que sea posible aplicar la mecánica de
un sistema basado en el razonamiento.
6.2.1 Creación de la Base de Casos
En el proyecto se ha decidido crear un entorno de fácil comprensión, en el cual un usuario pueda
crear y abrir una base de datos más cómodamente (Figura 19). La base de datos en Ozone puede
ser remota o local. Se ha decidido su conexión de forma local por la flexibilidad en la utilización
de recursos y para evitar problemas de conexión inesperados al servidor. El método de
recuperación de objetos en Ozone reconoce objetos definidos bajo una sola referencia, los
guarda y los recupera. En la implementación realizada en este proyecto este método ha sido
sobrecargado para recuperar colecciones de objetos, lo cual agiliza la recuperación.
Concretamente en la implementación del módulo de extracción se ha decidido introducir todos
los casos en una estructura ArrayList, y dicha estructura guardarla en Ozone bajo la referencia de
65
Estudio para la implementación de un sistema de razonamiento basado en casos
“Collection”, de igual modo también existe una estructura ArrayList que guarda todas las
definiciones de atributos. Esta estructura residirá en Ozone con la referencia de
“MetaCollection”
Figura 19: Ventana para crear y Abrir una base de Datos
Al crear la base de datos, el usuario podrá elegir su ubicación dentro del disco duro. Una vez se
le de un nombre y se guarde, la base de datos se lanzará automáticamente y se quedará en modo
espera. Si por el contrario, se desea abrir una base de datos, el usuario tendrá que abrir un
fichero.bat llamado de la misma manera que cuado creo la base de datos. De igual forma la base
de datos será lanzada y se quedará en modo espera.
6.2.2 El entorno de CBR Extraction Module
La aplicación CBR Extraction Module es el entorno con el que el usuario realizará la conexión a
la base de casos de Ozone. Un entorno sencillo para que el usuario pueda gestionar la base de
casos fácilmente y cómodamente.
66
Estudio para la implementación de un sistema de razonamiento basado en casos
6.2.2.1 Conexión a la Base de Casos
Gracias a la aplicación CBR (Figura 20) conectaremos con la base de casos Ozone. Si en ella
residen casos, estos se cargaran automáticamente, visualizándose una barra de progresión y el
número de casos insertados en la aplicación. Si por el contrario la base de datos se encuentra
vacía será preciso definir los metacasos (definir atributo y tipo) que el usuario considere
pertinentes para definir el entorno en el que desea aplicar un sistema de razonamiento basado en
casos. El usuario no podrá realizar ninguna otra operación hasta que no haya definido los
metacasos del entorno. Una vez definidos el programa ofrecerá la oportunidad de insertar, editar,
borrar y visualizar los casos.
Figura 20 : Entorno CBR Extraction Module
Para definir metacasos la aplicación dispone en el menú “edit” de una opción llamada “Metadata
case”, está opción definirá los atributos que se han de hallar en el entorno deseado. Se podrán
crear tantos atributos como el usuario desee, el tipo de atributo (String, Integer, Float y Boolean)
y un campo especial para indicar verdadero o falso. Este campo indica si el usuario desea que
dicho atributo sea visible a la hora de aplicar criterios de búsqueda. El campo visible es de suma
importancia pues no todos los atributos de un caso han de ser utilizados para realizar una
67
Estudio para la implementación de un sistema de razonamiento basado en casos
búsqueda, ya que existen atributos que interesaran que sean solución del caso, y otros que aun
considerando que no deben ser visibles son importantes en la definición de los casos.
Si existen datos, como se ha dicho anteriormente, se cargaran automáticamente en la aplicación.
La estructura de los metacasos (MetaCollection) será recuperada y la colección de metacasos
(colección de atributos y su tipo) en forma de estructura ArrayList se le será devuelta al
programa principal. De igual forma se efectuará el tratamiento para la colección de casos
(Collection). Para su mejor tratamiento en opciones de edición, borrado e inserción que más
adelante serán explicadas se decidió crear una tabla de hash para el rápido acceso a los datos.
Dicha estructura es creada y generada con todos los casos mientras se visualiza la barra de
progresión anteriormente mencionada en el primer párrafo de este punto.
6.2.2.2 Definición de atributos
Como se muestra en la Figura 21, a la hora de definir atributos del entorno existe un atributo
inicial inamovible que todo caso tendrá insertado. Dicho atributo es una referencia, necesaria
para las operaciones de búsqueda, edición y borrado de un caso en la base de datos. El tipo de
dato es String y por supuesto no es visible a la hora de realizar búsquedas de similitudes, ya que
es un identificador único para cada caso nuevo insertado en el CBR. (Figura 21).
Figura 21. Definición de Metacasos
68
Estudio para la implementación de un sistema de razonamiento basado en casos
Para ilustrar el funcionamiento de la aplicación a lo largo del documento se empleará el ejemplo
de una base de casos de DVD’s. Para ello se podría emplear los siguientes atributos (Figura 22):
•
Name Dvd: Titulo de la película
•
Composer: El Compositor de la banda sonora
•
Director : Director de la película
•
Year: Año de Salida de la película
•
Price: precio del Dvd
•
Especial edition: Dvd Edición especial remasterizada y extras
Figura 22. Ventana metacasos con atributos definidos
Cada vez que se desee añadir un atributo se ha de presionar el botón “Add Attribute”, si por el
contrario se desea eliminar algún atributo tan solo se ha de marcar el numero correspondiente en
la casilla y presionar el botón “Delete Attribute”.
6.2.2.3 Manipulación de casos
El principal activo de todo sistema CBR es la base de casos para ello una vez el usuario haya
introducido todos los atributos deseados (metadata), la aplicación ofrecerá la opción de añadir
casos en la base de datos. Para este fin se dispone de la opción de menú “Insert Case”, la cual
69
Estudio para la implementación de un sistema de razonamiento basado en casos
sabiendo los atributos deseados tan solo pedirá que sean rellenados los campos (Figura 23). Cada
vez que se utilice esta opción se estará dotando al sistema de un caso. Cuantos más casos
basados en experiencia se introduzcan mejores búsquedas realizará el sistema dando el caso mas
parecido de entre sus criterios de búsqueda. Como se puede apreciar en la Figura 23 al lado de
cada atributo existe un campo vacío para introducir el valor del atributo, y en la tercera columna
se indica el valor esperado. Si el usuario se equivoca al introducir un parámetro se le avisará
inmediatamente del error cometido. Una vez salvado el caso este será indexado de forma
secuencial en la estructura ArrayList de casos, insertado también en la tabla de hash para su
rápido acceso. Y finalmente insertada en la base de casos de Ozone.
Figura 23. Ventana insertar nuevo caso
Para mantener los casos correctos en una aplicación CBR se ha añadido el poder editarlos y
borrarlos en el momento que el usuario desee. Si se desea editar o borrar un caso de la base de
casos aparecerá en la aplicación una ventana como la siguiente (Figura 24):
Figura 24. Solicitud de referencia del caso edición/borrado
70
Estudio para la implementación de un sistema de razonamiento basado en casos
Si la referencia introducida existe mostrará el caso al que pertenece, mostrará todos sus atributos
y valores que contiene el caso ya sean visibles o no visibles. Esto se realiza de esta manera para
que el usuario pueda ver todos los atributos y sus valores antes de decidir si esta seguro de
querer eliminar el caso. Si el usuario ha decidido borrar un caso de la base de datos le aparecerá
en pantalla la siguiente captura (Figura 25).
Figura 25. Borrar un caso de la base de casos
Si se desea borrar el caso en cuestión, se pedirá confirmación para comprobar que realmente el
usuario este seguro de quererlo eliminar. De igual forma se procederá si el usuario desea editar
un caso, la única diferencia es que al borrar un caso sus atributos no se pueden modificar, solo es
posible ver la información del caso. Por el contrario si se desea editar un caso todos los atributos
podrán ser modificados a excepción de la referencia, la cual será inmutable desde la creación del
caso hasta su eliminación.
Cada vez que el caso sea editado será indexado en la estructura ArrayList de casos, en el mismo
lugar que ocupaba antes de la edición. Insertado en el mismo lugar en la tabla de hash para su
rápido acceso. Y finalmente insertado en el mismo lugar de la base de casos de Ozone. La
eliminación del caso borrara el caso en los mismos lugares antes mencionados.
71
Estudio para la implementación de un sistema de razonamiento basado en casos
6.2.2.4 Visualización de casos
El usuario dispone de una opción en la cual puede visualizar todos los casos existentes en la base
de casos. La visualización mostrará todos los campos existentes en un caso, hayan sido
declarados visibles o no visibles. Esta opción, “show all cases” permite la visualización del
código de referencia de los casos. De esta y otras formas que más adelante se comentaran, un
usuario podría saber la referencia de un caso (Figura 26).
Figura 26. Visualización de todos los casos de la base de casos con todos sus atributos
6.2.2.5 Definición del caso base
Hasta aquí se ha explicado todo lo referente a la gestión de casos en un CBR, es decir su
inserción, borrado y edición de casos. Estas operaciones son necesarias para mantener una buena
base de casos correcta. Pero la importancia más grande de un CBR es su motor de similitudes
que opera sobre los casos.
En este subapartado se explicará la conexión realizada con Selection Engine y se darán cuatro
ejemplos de cómo definir casos base. En el primero, se dará un caso base muy sencillo en el que
solo se aplicará un criterio de búsqueda. En el segundo Se especificará un caso más complicado
utilizando bastantes criterios. En el tercero se aplicará otras selecciones importantes. Y
finalmente se mostrará un caso con búsquedas de exclusión.
Como el entorno pensado para la base de datos ha sido la compra-venta de DVD’s. Un usuario
podrá adquirir aquellos DVD’s que según sus criterios de búsqueda han dado como resultado los
72
Estudio para la implementación de un sistema de razonamiento basado en casos
tantos por ciertos más elevados. En la figura anterior (Figura 26) se puede ver una lista de 1000
casos insertados de DVD’s para testear el buen funcionamiento de la aplicación. Ahora que la
aplicación dispone de una buena base de casos, se mostrará la ventana para la selección de los
criterios, es decir lo que comúnmente se llama caso base deseado. Para ello la aplicación dispone
opción “New Search Similarity”. Una vez se ha elegido esta opción el programa realiza la
conversión de los datos a las estructuras necesarias requeridas por Selección Engine a la hora de
buscar las similitudes. Para este fin, se han modificado las clases para que en vez de cargar datos
desde un fichero de texto como originalmente realizaba, se carguen datos desde las estructuras
ArrayList de casos (collection) y de metacasos (Metacollection) definidas en la aplicación.
Estas estructuras serán enviadas a la clase ItemManager, previamente modificada para que lea
las estructuras y genere una colección de Ítems, estructura que reconoce Selection Engine. Para
este fin de han modificado las clases Items, Item, Trait, Traits, Traitdescriptors y
Traitdescriptor. Una vez generadas las estructuras, el sistema ofrece de forma visual todos los
atributos visibles y sus valores con opciones de búsqueda, es decir, la elección de caso base
(Figura 27).
Como se puede observar en la Figura 27 se muestran 7 grupos en la aplicación:
GRUPO “ATTRIBUTE”: Es el grupo que donde estarán los atributos que el usuario ha
utilizado para definir el entorno en el cual desea aplicar el CBR. Aquellos atributos en los cuales
el usuario definió su visibilidad a “false” no serán visibles en esta ventana ya que consideró que
el atributo no debía ser utilizado a la hora de realizar búsquedas.
GRUPO “PREFER”: Es el grupo en el que se encuentra un checkBox. El usuario podrá elegir
sobre el atributo en cuestión, si desea realizar una búsqueda por preferencia o no. Si el checkbox
está activado se aplicaran los grupos “prefer value” y “importance” para encontrar las similitudes
con los casos y el nivel de importancia.
GRUPO “PREFER VALUE”: Es el grupo formado por todas las variaciones de casos
introducidos referentes al Atributo en cuestión. Se presenta en forma de combobox ordenado y
sin repetición de valores. Los combobox que se pueden encontrarse en este grupo dependen del
tipo de atributo definido, así pues existirán combobox para datos string, para datos de tipo
integer, para datos float y para datos Boolean, aunque en este último solo existirán 2 valores,
true o false
GRUPO “IMPORTANCE”: Es el grupo en el que se puede elegir la importancia que se desea
al valor seleccionado del grupo “prefer value”. Existen 5 niveles de importancia comprendidos
desde el 1 al 5, donde el grado 1 indica la menor importancia posible y el grado 5 la mayor.
73
Estudio para la implementación de un sistema de razonamiento basado en casos
GRUPO “REQUIRE”: Es el grupo en el que se encuentra un checkBox. El usuario podrá cosas
muy concretas, valores concretos y rangos que desea. Todo lo que no cumpla estos valores o
rangos serán casos descartados ya de por si. Si el checkbox está activado se aplicaran los grupos
“operator” y “require value”.
GRUPO “OPERATOR”: Es el grupo formado por un combobox en el que se puede elegir las
operaciones que el usuario desea sobre el grupo “require value”. Las operaciones que se pueden
realizar dependerán del tipo de atributo. Para valores de tipo string ( =, /=), para operaciones de
tipo integer y float (=, /=, >, >=, <, <=) y finalmente para operaciones de tipo bolean ( = ). Esta
último tipo de dato solo requiere de la operación igual, ya que tan solo serán dos valores (true,
false).
GRUPO “REQUIRE VALUE”: Es el grupo formado por todas las variaciones de casos
introducidos referentes al Atributo en cuestión. Se presenta en forma de combobox ordenado y
sin repetición de valores. Es decir presenta las mismas características que el grupo “prefer
value”, la diferencia es que el grupo “require value” esta asociado a la activación del checkBox
del grupo “require”.
Figura 27. Especificación de los criterios de búsqueda (el caso base)
74
Estudio para la implementación de un sistema de razonamiento basado en casos
Una vez definido el caso base el usuario dispone del botón “Get Similar Cases” con el cual podrá
encontrar los casos más parecidos con el buscado. Para ello se recuperan los componentes de la
ventana que tienen que ver con los criterios del usuario. Los criterios son obtenidos y
clasificados según son de requerimiento o de similitud. Los criterios de similitud serán
clasificados en las clases similarityCriteria y similarityWeights, mientras que los criterios de
requerimiento estarán contenidos en filterCriteria. Ninguna de estas tres clases y subclases
creadas por ellas han sido modificadas, y los métodos en ellas se utilizan directamente.
Originalmente Selection Engine hacia uso de la clase QueryReader, clase que leía desde un
fichero los criterios de búsqueda. Obviamente esta clase ya no es utilizada.
Para los siguientes ejemplos más complejos en los cuales se marque la casilla “prefer” se dará a
entender que el usuario prefiere el valor del atributo seleccionado respecto a los otros existentes.
En el momento que sea marcada la casilla “require” se dará a entender que el usuario condiciona
de alguna forma el valor del atributo.
Se ha de recordar que:
1.- Al marcar la casilla “prefer” en atributos de tipo Integer o Floats internamente se está
utilizado el operador “~” que significa “alrededor”.
2.- Al marcar la casilla “prefer” en atributos de tipo String o Boolean internamente se está
utilizando el operador “%” que significa “preferencia”.
3.- Al marcar la casilla “require” en atributos de tipo Integer o Float las operaciones serán
de (=, /=, >, >=, <, <=). En atributos de tipo String las operaciones serán de (=, !=),
marcar la operación de != se esta utilizando el operador “!%” que significa “exclusión”.
Para valores boleanos solo existirá el operador “=” ya que tan solo existen dos valores
en los boleanos “true” o “false” y seleccionar a uno, es excluir al otro.
Ejemplo 1
Si tan solo se utiliza el atributo “Director”, y como valor preferido “Steven Spielberg”(Figura
28), al obtener los casos similares mostraría los 30 primeros casos en los que se ha encontrado
dicho valor con un 100 % de similitud (Figura 29). Esto es así puesto que existen una gran
variedad de casos en los que el atributo “Director” corresponde a “Steven Spielberg”. En todos
los demás casos en los que este atributo no correspondiera, no se habría obtenido ningún tanto
por ciento de similitud. Así pues se puede comprobar que el sistema CBR se vuelve más
eficiente cuantos más criterios de búsqueda son utilizados.
75
Estudio para la implementación de un sistema de razonamiento basado en casos
Figura 28. Ejemplo 1
Figura 29. 100 % de similitud al aplicar una búsqueda sencilla
76
Estudio para la implementación de un sistema de razonamiento basado en casos
Ejemplo 2
Por el contrario si se aplica correctamente el potencial de búsqueda (Figura30) que ofrece el
disponer de varios atributos a elegir, devolverá los casos más parecidos al gusto del usuario
(Figura 31).
Por ejemplo:
•
Atributo director corresponda a “Steven Spielberg” con una importancia de 5
•
Atributo compositor corresponda a “john williams” con una importancia de 4
•
Atributo categoría sea “acción” con una importancia de 3 y que además se requiera que sea
igual a “acción”.
•
Atributo año de la película este alrededor de 1995 con una importancia de 3 y al mismo
tiempo se requiera que solo muestre aquellas películas que estén por debajo del año 2000.
•
Atributo evaluación corresponda a 7 con una importancia de 4 y al mismo tiempo se
requiera que sea mayor de 5.
•
Atributo precio corresponda a 10.50 € con una importancia de 4 y que al mismo tiempo
requiera que el dvd sea mas barato o igual a 15.00 €
•
Atributo edición especial corresponda a true con una importancia de 4
Figura 30. Ejemplo 2
77
Estudio para la implementación de un sistema de razonamiento basado en casos
Figura 31. Resultado de definir más criterios de búsqueda
Como se muestra en la captura anterior, el programa ordenará como primer caso aquel que tiene
la similitud más alta respecto a los otros. Como se puede apreciar, en esta ventana (Figura 31)
solo se muestran los atributos que se definieron visibles.
Ejemplo 3
La especificación de los criterios de búsqueda puede verse en la Figura 32, y sus resultados en la
Figura 33.
•
Atributo director corresponda a “Robert Zemeckis” con una importancia de 4.
•
Atributo compositor corresponda a “Alan Silvestri” con una importancia de 5 y al mismo
tiempo se requiere que el compositor sea igual a “Alan Silvestri”.
•
Atributo categoría sea “Ciencia-ficción” con una importancia de 4.
•
Atributo productora sea “universal pictures” con una importancia de 2
•
Atributo año de la película este alrededor del 2003 con una importancia de 4.
•
Atributo evaluación corresponda a 9 con una importancia de 4.
•
Atributo precio corresponda a 20.10 € con una importancia de 4 y que al mismo tiempo
requiera que el dvd sea mas caro o igual a 15.00 €
•
Atributo edición especial corresponda a true con una importancia de 5 y al mismo tiempo
requiera que sea igual a true.
78
Estudio para la implementación de un sistema de razonamiento basado en casos
•
Atributo dolby corresponda a true con una importancia de 5 y al mismo tiempo requiera que
sea igual a true.
Figura 32: Ejemplo 3
Figura 33: Búsqueda más exhaustiva
79
Estudio para la implementación de un sistema de razonamiento basado en casos
Ejemplo 4
Finalmente el último ejemplo de criterios de búsqueda se puede ver en la Figura 34, y su
resultado en la Figura 35.
•
Atributo director corresponda a “John Woo” con una importancia de 4 y sea excluido el
director “Steven Spielberg”.
•
Atributo compositor corresponda a “Trevor jones” con una importancia de 5 y que sea
excluido el compositor “John Williams”.
•
Atributo categoría sea “fantástico” con una importancia de 4 y que sea excluido “cienciaficción”.
•
Atributo duración 120 minutos con una importancia de 1 y mayor o igual a 100 minutos.
•
Atributo evaluación corresponda a 9 con una importancia de 5 y que sean mayores o igual a
6.
•
Atributo edición especial corresponda a true con una importancia de 3.
•
Atributo dolby corresponda a true con una importancia de 3.
Figura 34: Ejemplo 4
80
Estudio para la implementación de un sistema de razonamiento basado en casos
Figura 35: ejemplo con exclusión
6.2.2.6 Presentación extendida de resultados
Como puede verse en los ejemplos citados anteriormente, los resultados corresponden a los
atributos visibles que de hayan definido (6.2.2.1 Definición de atributos). Pero si el usuario
desea ver todos los atributos de algún resultado, solo ha de realizar doble click encima del
resultado que desee para que aparezca una ventana complementaria de información (figura 36)
Figura 36. Muestra todos los atributos
81
Estudio para la implementación de un sistema de razonamiento basado en casos
Una vez generados los 30 mejores casos correspondientes a los criterios de búsqueda, el sistema
ofrece la oportunidad de salvar los resultados en formato html, para poder consultar los
resultados en el momento que se desee. El usuario ha de elegir el nombre y la ubicación donde
guardará el archivo.html. El formato será tal y como se puede apreciar en la siguiente Figura 37.
Una vez los datos estén en html el usuario podrá imprimirlos desde su propio navegador, e
incluso con las herramientas necesarias poner en Internet la página con los resultados de la
búsqueda para que sea accesible a todo el que quiera verla. Los atributos mostrados serán los
mismos fueron definidos como visibles y el máximo número a mostrar será de 30 casos, los 30
casos si existen con más porcentaje de similitud hallado.
Figura 37. Resultados en formato html
Hasta aquí se ha explicado la utilización y uso de la aplicación, así como sus partes graficas más
relevantes a la hora de hacer funcionar una aplicación CBR. Gracias al aspecto genérico del
entorno, el usuario puede desarrollar sus propios sistemas, crear los datos, insertar casos,
82
Estudio para la implementación de un sistema de razonamiento basado en casos
editarlos y borrarlos de manera sencilla. Así como guardar los casos más similares en formato
html para su posterior revisión.
6.2.2.7 Definición del número máximo de casos Similares
Al presentar los casos más similares respecto a los criterios de búsqueda, sólo son mostrados por
defecto los primeros 30 casos con los porcentajes más elevados obtenidos. Si el usuario lo desea
este número puede ser definido por el en cualquier momento. Para ello dispone de una opción
llamada “view max similar cases” en que se muestra el número actual de casos similares, pero si
es deseo del usuario puede modificarlo en la misma ventana (Figura 38)
Figura 38. Muestra y edita el número máximo de casos similares que se desean mostrar
Una vez finalizada la aplicación y cerrada, al volverla a ejecutar el número por defecto será de
30 casos similares. Así pues si es deseo del usuario otro valor tendrá que volverlo a modificar.
83
Estudio para la implementación de un sistema de razonamiento basado en casos
7. CONCLUSIONES
Este proyecto, me ha ayudado a comprender un concepto totalmente nuevo para mí, los sistemas
CBR me eran totalmente desconocidos hasta que acepte el proyecto de estudio y revisión
biográfica de los sistemas basados en el razonamiento. Ahora comprendo el potencial que son
capaces de manejar y la inmensidad de dominios en los que se podría aplicar su utilización. Pues
las necesidades de información pueden ser definidas modeladas e insertadas como base a futuras
preguntas.
Es la experiencia lo que hace a un hombre madurar, encapsular la experiencia vivida para
obtener la mejor respuesta a un problema es de algún modo hacer que un programa “madure”,
crezca en información, conozca aquellos casos en que fallo, para intentar, para definir de alguna
forma que en un dominio concreto “no se caiga dos veces en la misma piedra”.
Uno de los puntos más importantes para mi ha sido la hibridación de CBR con otros sistemas
inteligentes y como dicha fusión ha mejorado considerablemente la respuesta del sistema. Los
métodos de recuperación y adaptación de los casos han sido para los más interesantes. Pues
gracias a que curse Inteligencia Artificial como asignatura optativa me ha ayudado a comprender
en gran medida los algoritmos utilizados en la recuperación de casos , así como las reglas que se
suelen aplicar a la hora de adaptar los casos. Pero todo y que considero que la idea de aplicar un
sistema basado en reglas para la adaptación de casos es bastante buena, he de decir que
considero que ofrece más fiabilidad que la adaptación se realice mediante un usuario, pues
existen multitud de situaciones no programables que requieren de un trato directo del usuario
con el software.
El proyecto en si ha tenido una gran parte dedicada a la revisión bibliográfica de los apartados
del ciclo CBR y a la fusión de sistemas híbridos con otras áreas. Esta revisión me ha ayudado
mucho a comprender los diferentes dominios de aplicación, pues cada autor ofrecía una idea
novedosa o informativa al tratamiento de los sistemas CBR, y después de realizar la revisión he
podido comprobar que el algoritmo más utilizado en el cálculo de la similitud de casos por casi
todos los autores es el nearest neighbor. Un algoritmo fácil de comprender y que ofrece grandes
resultados en la búsqueda de similitudes. Pero hay que decir que existen dominios en los que se
requiere quizás unos tiempos de respuesta mayores, es por ello que los autores no se estancan en
un solo método y buscan la eficiencia, la eficacia y la rapidez cada vez mayores en un sistema de
razonamiento basado en casos.
He de decir que fue complicada la integración de Selection Engine, puesto que todas las clases
no estaban documentadas, y tuve que hacer su seguimiento paso a paso para comprobar como
84
Estudio para la implementación de un sistema de razonamiento basado en casos
realizaba la gestión de los casos, como definía los atributos y como calculaba las similitudes
entre los casos. Por el contrario me ha gustado mucho trabajar con la base de datos Ozone, que
aunque parezca sencilla de usar, encierra una gran metodología y complejidad de
funcionamiento que creo mejorará con las nuevas versiones que sean implementadas.
En resumen este proyecto me ha proporcionado conocer los Sistemas CBR su uso y aplicación
en los diferentes entornos, así como su gran potencial en el presente y en el futuro. Por último
me gustaría dar las gracias al grupo BANZAI por haberme brindado la oportunidad de haber
realizado este proyecto.
85
Estudio para la implementación de un sistema de razonamiento basado en casos
REFERENCIAS
[1] Schank, R.C. and Abelson, R.P. Scripts,Plans, Goals and Understading. Erlbaum, HillsDale,
New Jersey, 1977.
[2] Schank, R.C. Dynamic Memory: A Theory of Learning in Computers and people. Cambridge
University Press. New York, 1982.
[3] Kolodner, J. L.. Maintaining Organization in a Dynamic Long-Term Memory. Cognitive
Science, 7(iv): pp.243-80. 1983
[4] Kolodner, J. L. . Reconstructive Memory: A Computer Model. Cognitive Science, 7(iv):
pp.281-28. 1983
[5] Kolodner, J.L. Retrieval and Organization Strategies in conceptual Memory. Lawrence.
Erlbaum, Hillsdale, New jersey, 1984.
[6] Simpson, R. L. A Computer Model of Case-Based Reasoning in Problem Solving: An
Investigation in the Domain of Dispute Mediation. Technical Report GIT-ICS-85/18, Georgia
Institute of Technology, School of Information and Computer Science, Atlanta ,US.1985
[7] Bain, W.M. Case-Based Reasoning: A Computer Model of Subjective Assessment. Ph.D.
Thesis, Yale University, Yale, CT, US. 1986
[8] Hammond, K.J. CHEF: A Model of Case-Based Planning. In Proc. American Association for
Artificial Intelligence, AAAI-86, August 1986. Philadelphia, PA, US. 1986.
[9] Sycara, E. P. Resolving adversial conflicts: An approach to Integrating Case-Based and
Analytic Methods. Technical Report GIT-ICS-87/26, Georgia Institute of Technology, School of
Information and Computer Science, Atlanta GA. 1987.
[10] Koton. P. Using experience in learning and problem solving. Massachusetts Institute of
Technology, Laboratory of Computer Science, Ph.D. Thesis MIT/LCS/TR-441. 1989.
[11] Hinrichs, T.R. Problem solving in open worlds. Lawrence Erlbaum Associates. 1992.
86
Estudio para la implementación de un sistema de razonamiento basado en casos
[12] Porter, B.W. & Bareiss, E.R. PROTOS: An experiment in knowledge acquisition for
heuristic classification tasks. In Proceedings of the First International Meeting on Advnces in
Learning (IMAL), Les Arcs, France, pp.159-74. 1986.
[13] Ashley, K. D., and Rissland, E.L. , “ACase-Based Approach to Modelling Expertise”, in
IEEE Expert, Fall, pp 70-77. 1988
[14]. By David Hinkle and Christopher Toomey. Applying Case-Based Reasoning to
Manufacturing AI Magazine 16(1): 65-73 (Spring 1995).
[15]
Ralph Bergmann, Sean Breen, Mehmet Göker, Michel Manago, Jürgen Schumacher,
Armin Stahl, Emmanuelle Tartarin, Stefan Wess, Wolfgang Wilke. The INRECA-II Methodology
for Building and Maintaining CBR Applications. 1998
[16] Smyth, B. and Keane, M.T. “Remembering to forget”. In Proceedings of the 16th
International Conference on Artificial Intelligence. IJCAI-95, 1995.
[17] Watson,I. and Gardigen, D. “ A Distributed Case-Based Reasoning. Application for
engineering Sales Support. In Proceedings of the 16th International Conference on Artificial
Intelligence. IJCAI-99, 1999.
[18] Kolodner, J.L. Case-Based Reasoning. Morgan Kaufmann Publishers. San Mateo,
California. 1993
[19] Aamodt,A.and Plaza, E. “Case-based Reasoning: Foundational Issues, Methodological
variations, and System approaches” Artificial Intelligence communication vol 7 pp 39-59. 1994
[20] Min Soo Suh, Won Chul Jhee, Young Kwan Ko and Albert Lee. A case-based expert
system approach for quality design. Department of industrial enginnering university of Toronto,
and Korea. Pp 1-10. 1998
[21] David B. Leake, Larry Birnbaum, Kristian Hammond, Cameron Marlow and Hao Yang.
Integrating Information Resources: A Case Study of Engineering Design Support. Pp1-3, 6-7.
1999
[22] Katy Börner. Efficient case-base esrtucture generation for design support, Kluwer
academic publishers. Pp 1-5 . 2001.
87
Estudio para la implementación de un sistema de razonamiento basado en casos
[23] Andrés Gómez de Silva Garza y Mary Lou Maher. Design by interactive exploration Using
Memory based techniques. Revista Tal, Vol Y, Num 12. 1998. pp. 200-210.
[24] Stephanie E. August and Lawrence P. McNamee. Integrating Analogical Reasoning in a
Natural Language Understander. Computer Science Department, University of California
Los Angeles, California. Pp 3-8. 1990
[25] Daniel Macaya, Joaquim Meléndez y Joan Colomer. Supervisión basada en casos de
controladores PID. Departament d’Electrònica Informàtica i Automàtica (E.I.A.) – Universitat
de Girona. Pp 1-7. 1997
[26] Andrés Gómez de Silva Garza and Mary Lou Maher Developing Case-Based Reasoning for
Structural Design,. IEEE Expert. Volume 11, Number 3. June 1996
[27] Andrés Gómez de Silva Garza y Mary Lou Maher . The Adaptation of Structural System
Designs Using Genetic Algorithms,. Department of Architectural and Design Science
University of Sydney, Australia. Pp 1-9, 1996
[28] Goldberg, “Genetic algorithms in search, optimization and machine learning”, AddisonWesley publishing company, Inc , 1989.
[29] Pierre-Antoine Champán. A model to represent design episodes for reuse assistance with
interactive case-based reasoning. Cognition & Experience team LISI, Universit Claude Bernard
Lyon1. Pp 1-5. June 2001
[30] David B. Leake, Andrew Kinley, and David Wilson. Case-Based Similarity Assessment:
Estimating Adaptability from Experience. Computer Science DepartmentLindley Hall 215,
Indiana University. Pp 1-6. 1997.
[31] Berger, J.. ROENTGEN: A Case-based Radiation Therapy Planner. Ph.D. Dissertation, The
University of Chicago. Computer Science Department. 1995.
[32] Sycara, K. Using case-based reasoning for plan adaptation and repair. In Kolodner, J., ed.,
Proceedings of the DARPA Case-Based Reasoning Workshop,425-434. San Mateo, CA:
Morgan Kaufmann. 1988.
88
Estudio para la implementación de un sistema de razonamiento basado en casos
[33] Costas Tsatsoulis Case-Based Design And Learning In Telecommunications, Department of
Electrical and Computer Engineering. The University of Kansas. Pp 1-10 1989
[34] W. Ahn and D. L. Medin. A two-stage model of category construction. Cognitive
Science, (16):81-121, 1992
[35] Stefania Montani, Riccardo Bellazzi. Integrating Case Based and Rule Based Reasoning in
a Decision Support. Dipartimento di Informatica e Sistemistica, Università di Pavia pp 1-5. 1999
[36] A.Gómez, R. Pavón, R. Laza, J.M. Corchado. Integrating rule based Systems which Change
along Time in a CBR Environment. Departamento de informática de la Universidad de Vigo y
departamento de informática y automática de la universidad de Salamanca. Pp 1-3. 2002
[37] Golding, A. R. Pronouncing Names by a Combination of Rule-Based and Case-Based
Reasoning. Knowledge Systems Laboratory, October, 1991.
[38] Mérida-Campos, Cortés, Ulises; Roda, Ignasi R, Carlos; Rollón, Emma. "Deliverable 4.1.
Report on current reasoning engine practice and integration strategies", RIMSAT, University
of Girona: 2003.
[39] Stefanie Brüninghaus and Kevin D. Ashley. Reasoning for Predicting the Outcome of Legal
Cases . Learning Research and Development Center and School of Law University of
Pittsburgh. Pp 1-5, 10-15. 2003
[40] L. Karl Branting, John D. Hastings and Jeffrey A. Lockwood. Integrating Cases and
Models for Prediction in Biological Systems. Department of Computer Science, Department of
Plant, Soil, and Insect Sciences of University of Wyoming. Pp1-5, pp 10-15. 1997
[41] Bjarne K. Hansen and Denis Riordan. Weather Prediction Using Case-Based Reasoning
and Fuzzy Set Theory. New Brunswick Weather Centre Meteorological Service of Canada and
Faculty of Computer Science Dalhousie University. Pp1-4. 2000
[42] F. Fdez-Riverola 1, and J. M. Corchado. Employing TSK Fuzzy models to automate the
revision stage of a CBR system. Dept. Informática. University of Vigo, Dept. de Informática y
Automática, University of Salamanca. PP 1-10 2003
89
Estudio para la implementación de un sistema de razonamiento basado en casos
[43] T. Takagi and M. Sugeno. Fuzzy identification of systems and its application to modeling
and control. IEEE Trans. Systems, Man, and Cybernetics, 15:116- 132, 1985.
[44] Stefania Bandini, Sara Manzoni Knowledge Management Applications at Pirelli Tires: the
P-Race and P-Truck projects Dipartimento di Informatica Sistemistica e Comunicazione.
Università di Milano. Pp4 -15. 2000
[45] Taghi M. Khoshgoftaar, Yudong Xiao, and Kehan Gao. Multi-Objective Optimization by
CBR GA-Optimizer for Module-Order Modeling. Florida Atlantic University, Boca Raton,
Florida USA. Pp 1-6 2004
[46] Sushil Louis, Gary MacGraw y Richard O. Wyckoff. CBR Assisted Explanation of GA
Results. Department of Computer Science & Center for Research on Concepts and Cognition
Indiana University. August 1, 1992. Pp
[47] Martin O., Inge H., y Brede N. (1999). Applying CBR and Neural Networks to Noise
Planning. IJCAI ’99. WorkShop ML-5. Automating the Construction of Case Based Reasoners.
Stockholm, Sweden. 1999. Pag. 50-55.
[48] Juan M. Corchado and Brian Lees. A Hybrid case-based model for forecasting. Department
of Languages and Computing Systems University of Vigo, Department of Computing and
Information Systems University of Paisley, pp 1-8, 11- 20. 2002
[49] Ricardo B. Sovat y André C. P. L. F. de Carvalho .Retrieval and adaptation of cases using
an Artificial neural network. Instituto de Ciências Matemáticas e de Computação, Universidade
de São Paulo, São Carlos, SP, Brazil. Pp 1-5. 2001
[50] Belén Díaz-Agudo and Pedro A. González-Calero. CBROnto: A Task/Method Ontology For
CBR. Dep. Sistemas Informáticos y Programación Universidad Complutense de Madrid. Año
2002. pp 1 – 5.
[51] Luigi Ceccaroni, Ulises Cortés and Miquel Sánchez-Marré. OntoWEDSS: augmenting
environmental decision-support systems with ontologies. Fujitsu Laboratories of America and
Departamento de lenguajes i Sistemas Informáticos, Universidad Politécnica de Catalunya. pp 14, 12-13. Octover 2002
90
Estudio para la implementación de un sistema de razonamiento basado en casos
[52] Caspian. University of Wales.
http://www.aber.ac.uk/compsci/Research/mbsg/cbrprojects/getting_caspian.html
[53] Selection Engine. http://selectionengine.sourceforge.net
[54] NCARAI IDA Group. Nacodae. http://home.earthlink.net/~dwaha/software/nacodae/
[55] Indiana University. IUCBRF . http://www.cs.indiana.edu/~sbogaert/CBR/
[56] Artificial Intelligence Applications Institute AIAI. CBR-Shell.
http://www.aiai.ed.ac.uk/project/cbr/CBRDistrib/
[57] Acknosoft. Kate. http://www.acknosoft.com/
[58] TECINNO. CBR-Works http://www.tecinno.com
[59] Empolis. Orenge. http://www.searchtools.com/tools/orenge.html
[60] Cognitive Systems. Remind. http://www.ai-cbr.org/tools/remind.html
[61] ISoft. Recall. http://www.alice-soft.com/html/prod_recall.htm
[62] Esteem Software Inc. ESTEEM. http://www.ai-cbr.org/tools/esteem.html
[63] Brightware. ART* Enterprise. www.brightware.com
[64] The Ozone Proyect. Ozone. http://www.ozone-db.org
91
Estudio para la implementación de un sistema de razonamiento basado en casos
APÉNDICES
92
Estudio para la implementación de un sistema de razonamiento basado en casos
Apéndice A. Resumen de herramientas CBR
Herramientas académicas
Herramienta
Entorno
Dominio
Representación
Recuperación
Adaptación
Interfaz
Simple, se almacena
Nearest Neighbor
Mediante Reglas Línea de comandos
Aplicación
CASPIAN
MS-DOS
General
MAC
en un archivo ASCII
SELECTION
Cualquier computadora que contenga General
Simple, se almacena en Nearest Neighbor
ENGINE
la maquina virtual de Java, PCs
un fichero
No dispone
Entorno gráfico
No dispone
Entorno gráfico
Windows 95/98/NT, Sun Solaris y
Macintosh, plataformas Unix
NaCoDAE
IUCBRF
Cualquier computadora que contenga Tareas
de Estructurada,
K-nearest
la maquina virtual de Java, PCs asistencia naval
representación orientada neighbour
Windows 95/98/NT, Sun Solaris y
a objetos
Macintosh, plataformas Unix
Librería de casos
Cualquier computadora que contenga General
En tres tipos:
la maquina virtual de Java, PCs
1.-Almacenados en una neighbour
Windows 95/98/NT, Sun Solaris y
lista desordenada
Macintosh, plataformas Unix
2.- Archivo
K-nearest
Tres propuestas: No aplicable
1.- No
Adaptation
2.- Weighted
Average
B-tree-bached
3.- D-tree
3.- Weighted
Majority
CBR-Shell
Mozilla 1.2, Linux, Explorer 6.0, General
Simple, se almacena
nearest neighbor y
Medidas de
Windows XP y Mac OS
en un archivo ASCII
k-nearest neighbor
confianza
adaptativas
93
Applet java
Estudio para la implementación de un sistema de razonamiento basado en casos
Herramientas comerciales
Herramienta
Entorno
Dominio
Representación
Recuperación
Adaptación
Interfaz
Aplicación
KATE
Pc Windows, UNIX Sistemas inteligentes de Casos jerarquicos
Nearest neighbor e inducción, No dispone
soporte de decisiones
Intefaz personalizable
tecnicas de data mining, medidas
de similitud y pesos
CBR-Works
MS
Windows, Sistemas
de Modelos de dominio y nearest neighbor e inducción
Usando reglas
MAC, OS/2, UNIX clasificación, comercio casos con representación
electrónico,
mining,
selección
Entorno gráfico sencillo
de
data orientada a objetos
usar.
aplicaciones
de
Genera
CBR
con
interfaz o servidores
productos
Orenge
Independiente de la Sistemas Inteligentes de Flexible
Flexible y extensible.Busquedas Reglas
Plataforma
exactas, basadas en similitud y simples
búsqueda
de
información
ReMind
Pc
Windows, General
MAC, UNIX
muy No aplicable
difusas
Casos planos anidados y nearest neighbor, inducción y Mediante
Interfaz de desarrollo que
jerarquías ordenadas de plantillas (para consultas a bases formulas
se puede personalizar
símbolos
de datos)
94
Estudio para la implementación de un sistema de razonamiento basado en casos
Herramienta
Entorno
Dominio
Representación
Recuperación
Adaptación
Interfaz
Aplicación
ReCall
Pc
Windows, General
UNIX
Estructurada. Casos jerárquicos nearest neighbor e inducción
Reglas definidas por Entorno gráfico de
con relaciones. Representación
expertos y funciones
desarrollo
orientada a objetos. Herencia.
ESTEEM
Pc Windows
General.
Estructurada.
Orientada
Diagnostico
objetos. Casos anidados.
a nearest
neighbor
con Usando
funciones
generación inductiva de pesos. reglas
Atención al cliente.
y GUI Builder basado
en formularios
Se pueden añadir funciones de
similitud propias.
ART*Enterprise
Gran variedad General
Atributo-valor
con
muchos nearest neighbor
Funciones,
reglas
y Incluye
de entornos
tipos predefinidos. Orientada a
técnicas basadas en el constructor
objetos
conocimiento
interfaces
para usuario
95
un
de
gráficas
Estudio para la implementación de un sistema de razonamiento basado en casos
Apéndice B. Application Program Interface
All Classes
Cases
CasesGroup
CasesGroupImpl
CasesImpl
CBRProgram
CBRWindow
DataSetStatistics
ExampleFileFilter
FilterCriteria
FilterCriterion
FilterEngine
GetInfo
Item
ItemManager
Items
MetaInfo
MetaInfoGroup
MetaInfoGroupImpl
MetaInfoImpl
OrdenacionFloat
OrdenacionInteger
OrdenacionNombre
OzoneProgram
OzoneWindow
RepositoryOzone
ResultsWindow
SimilarItems
SimilarityCriteria
SimilarityCriterion
SimilarityCriterionScore
SimilarityCriterionScores
SimilarityDescription
SimilarityEngine
SimilarityWeight
SimilarityWeights
Trait
TraitDescriptor
TraitDescriptors
TraitPanel
Traits
TraitStatistics
TraitValue
WindowCaseDelete
WindowCaseEdit
WindowCaseNew
WindowCasesInfo
WindowCaseView
96
Estudio para la implementación de un sistema de razonamiento basado en casos
WindowMetaDataCase
WindowProgressBarReload
Cases.java
cbr
Interface Cases
All Known Implementing Classes:
CasesImpl, CasesImpl_Proxy
Method Summary
java.util.ArrayList list()
void setList(java.util.ArrayList list)
CasesGroup.java
cbr
Interface CasesGroup
All Known Implementing Classes:
CasesGroupImpl, CasesGroupImpl_Proxy
Method Summary
void addCases(CasesImpl cases)
java.util.ArrayList getCases()
CasesImpl getCases(int key)
void insertCase(int key, CasesImpl cases)
void removeCases(int key)
CasesGroupImpl.java
cbr
Class CasesGroupImpl
cbr.CasesGroupImpl
All Implemented Interfaces:
CasesGroup
97
Estudio para la implementación de un sistema de razonamiento basado en casos
Constructor Summary
CasesGroupImpl()
CasesGroupImpl
Method Summary
void addCases(CasesImpl cases)
Add cases to ArrayList of Cases
java.util.ArrayList getCases()
Rutun Cases
CasesImpl getCases(int key)
Return a Case of Cases
void insertCase(int key, CasesImpl cases)
Insert Case in list
void removeCases(int key)
Return Cases without case
CasesImpl.java
cbr
Class CasesImpl
cbr.CasesImpl
All Implemented Interfaces:
Cases
Constructor Summary
CasesImpl()
CasesImpl
Method Summary
java.util.ArrayList list()
Return a list of Attributes of case
void setList(java.util.ArrayList list)
Set List
CBRProgram.java
cbr
Class CBRProgram
java.lang.Object
|
+--cbr.CBRProgram
98
Estudio para la implementación de un sistema de razonamiento basado en casos
Constructor Summary
CBRProgram()
Method Summary
static void main(java.lang.String[] args)
Main of Program
(package run()
private)
Metod
void
run for create Desktop Environment of Aplication
CBRWindow.java
cbr
Class CBRWindow
java.lang.Object
|
+--java.awt.Component
|
+--java.awt.Container
|
+--java.awt.Window
|
+--java.awt.Frame
|
+--javax.swing.JFrame
|
+--cbr.CBRWindow
Constructor Summary
CBRWindow()
CBRWindow Inciate Window, build MenuBar, options & images
Method Summary
protected
void addBooleanFilterOperators(javax.swing.JComboBox list)
Add to combobox Bolean values
protected
void addNonNumericFilterOperators
(javax.swing.JComboBox list)
Add to combobox Not Numeric values
protected
void addNumericFilterOperators(javax.swing.JComboBox list)
Add to combobox Numeric values
(package private) cancelButton_actionPerformed()
void
Action button Cancel in Similarity Search
(package private) deleteCase_actionPerformed
void (java.awt.event.ActionEvent e)
Action button delete Case
99
Estudio para la implementación de un sistema de razonamiento basado en casos
(package private) disConnectionOzone_actionPerformed
void (java.awt.event.ActionEvent e)
Action button Disconnect Ozone
(package private) editCase_actionPerformed
void (java.awt.event.ActionEvent e)
Action Button Edit case
(package private) exit_actionPerformed(java.awt.event.ActionEvent e)
void
Action button Exit Program
(package private) exitWindow(java.awt.event.WindowEvent e)
void
Action button Exit Program window
(package private) help_actionPerformed(java.awt.event.ActionEvent e)
void
Action button Help
void iniciateQuery()
Iniciate new search similar attributes
private
void init()
Iniciate Window query with attributes
CaseBase and criterion search
(package private) insertCase_actionPerformed
void (java.awt.event.ActionEvent e)
Action button Insert new Case
java.util.ArrayList ItemsCombobox(int index)
Create list of non repeat values
protected
void loadItems()
Load Items for Similarity motor Cbr Similarity Engine
(package private) maxCasesView_actionPerformed
void (java.awt.event.ActionEvent e)
Action button View max cases and define number max
(package private) metaDataOpCase_actionPerformed
void (java.awt.event.ActionEvent e)
Action Button MetaDAtaCase insert, Show Window Insert
Metadata
void montar_Menubar()
Iniciate MenuBar of Aplication & Submenus
(package private) newfind_actionPerformed(java.awt.event.ActionEvent e)
void
Action button New Find Similarity
(package private) openDb_actionPerformed(java.awt.event.ActionEvent e)
void Action button open CaseBase
java.util.ArrayList Ordenacion(java.util.ArrayList lista,
java.lang.String typeAttribute)
Order alphabetically of Attributes & Order of smaller to bigger
(package private) submitButton_actionPerformed
void (java.awt.event.ActionEvent e)
Action button Similarity Cases, find similar cases
(package private) viewList_actionPerformed
void (java.awt.event.ActionEvent e)
Action button View List of cases, Show Window all cases
100
Estudio para la implementación de un sistema de razonamiento basado en casos
DataSetStatistics.java
net.sourceforge.selectionengine
Class DataSetStatistics
java.lang.Object
|
+--net.sourceforge.selectionengine.DataSetStatistics
Constructor Summary
DataSetStatistics(Items items)
Method Summary
private
void add(TraitStatistics traitStatistics)
add TraitStatistics to hashmap
private
void buildStatistics(Items items)
build Statistics
private
void createCollection(TraitDescriptors descriptors)
Create collection TraitStatistics
TraitStatistics get(java.lang.String traitName)
get traitStatistics
private
void measureItemTraits(Item item)
measureItemTraits
FileFilter.java
cbr
Class ExampleFileFilter
java.lang.Object
|
+--javax.swing.filechooser.FileFilter
|
+--cbr.FileFilter
Constructor Summary
ExampleFileFilter()
Creates a file filter.
ExampleFileFilter(java.lang.String extension)
Creates a file filter that accepts files with the given extension.
ExampleFileFilter(java.lang.String[] filters)
Creates a file filter from the given string array.
ExampleFileFilter(java.lang.String[] filters,
java.lang.String description)
Creates a file filter from the given string array and description.
101
Estudio para la implementación de un sistema de razonamiento basado en casos
ExampleFileFilter(java.lang.String extension,
java.lang.String description)
Creates a file filter that accepts the given file type.
Method Summary
boolean accept(java.io.File f)
Return true if this file should be shown in the directory pane,
false if it shouldn't.
void addExtension(java.lang.String extension)
Adds a filetype "dot" extension to filter against.
java.lang.String getDescription()
Returns the human readable description of this filter.
java.lang.String getExtension(java.io.File f)
Return the extension portion of the file's name .
boolean isExtensionListInDescription()
Returns whether the extension list (.jpg, .gif, etc) should show
up in the human readable description.
void setDescription(java.lang.String description)
Sets the human readable description of this filter.
void setExtensionListInDescription(boolean b)
Determines whether the extension list (.jpg, .gif, etc) should
show up in the human readable description.
FilterCriteria.java
net.sourceforge.selectionengine
Class FilterCriteria
java.lang.Object
|
+--net.sourceforge.selectionengine.FilterCriteria
Constructor Summary
FilterCriteria()
Method Summary
void add(java.lang.String field,
java.lang.String operator, java.lang.String value)
Add collection of filterCriterion
java.lang.Object clone()
This has to return Object because that's how it's defined in
the super class
102
Estudio para la implementación de un sistema de razonamiento basado en casos
java.util.Iterator iterator()
Iterator
private
void setValues(java.util.ArrayList newValues)
Set values
int size()
get int Size
FilterCriterion.java
net.sourceforge.selectionengine
Class FilterCriterion
java.lang.Object
|
+--net.sourceforge.selectionengine.FilterCriterion
Constructor Summary
protected FilterCriterion(java.lang.String fieldName,
java.lang.String operator, java.lang.String value)
Method Summary
java.lang.String getFieldName()
Return String Attribute
int getOperator()
Return integer Operator
java.lang.String getOperatorAsString()
Return String Opertor
TraitValue getValue()
Return Value
boolean itemViolates(Item item)
Return if Item violates criterion
private operatorToString(int operator)
java.lang.String
Return String Opertor
private
int stringToOperator(java.lang.String operator)
Return intOpertor
FilterEngine.java
net.sourceforge.selectionengine
Class FilterEngine
java.lang.Object
|
+--net.sourceforge.selectionengine.FilterEngine
103
Estudio para la implementación de un sistema de razonamiento basado en casos
Constructor Summary
FilterEngine()
Method Summary
Items filterItems(Items items, FilterCriteria filterCriteria)
Return Items filtered
private violatesCriteria(Item item, FilterCriteria criteria)
boolean
Return if violated criteria user
GetInfo.java
cbr
Class GetInfo
java.lang.Object
|
+--cbr.GetInfo
Constructor Summary
GetInfo(java.lang.String file, cbr.ExternalDatabase db)
GetInfo
Item.java
net.sourceforge.selectionengine
Class Item
java.lang.Object
|
+--net.sourceforge.selectionengine.Item
Constructor Summary
protected Item(TraitDescriptors traitDescriptors)
Method Summary
int getTraitDataType(java.lang.String traitName)
104
Estudio para la implementación de un sistema de razonamiento basado en casos
return datatype of Attribute
TraitValue getTraitValue(java.lang.String traitName)
return Value of Attribute
java.util.Iterator iterator()
Iterator
protected
void loadFromDelimitedCase(TraitDescriptors traitDescriptors,
java.util.ArrayList caseItem)
Assumption: good data is passed in.
ItemManager.java
net.sourceforge.selectionengine
Class ItemManager
java.lang.Object
|
+--net.sourceforge.selectionengine.ItemManager
Constructor Summary
ItemManager(java.util.ArrayList listMeta,
java.util.ArrayList listCases)
Add Cases to collection Items
Method Summary
Items getItems()
getItems
TraitDescriptors getTraitDescriptors()
get TraitDescriptors
Items.java
net.sourceforge.selectionengine
Class Items
java.lang.Object
|
+--net.sourceforge.selectionengine.Items
Constructor Summary
protected Items(TraitDescriptors traitDescriptors)
This is the only constructor and it requires TraitDescriptors Technically,
Items doesn't need to know anything about TraitDescriptors, but a lot of the
people who use Items (actually, Item) do.
Method Summary
protected
void add(Item item)
105
Estudio para la implementación de un sistema de razonamiento basado en casos
void add(TraitDescriptors traitDescriptors,
java.util.ArrayList caseItem)
protected
This method create Item and asociate your traitDescriptors
and arraylist of collection attribute - value.
java.lang.Object clone()
clone Items and return
TraitDescriptors getTraitDescriptors()
return traitDescriptors, Attributes of case
java.util.Iterator iterator()
Iterator for collection
void setValues(java.util.ArrayList newValues)
private
Asociate new collection
int size()
Number of items in the collection
Metainfo.java
cbr
Interface MetaInfo
All Known Implementing Classes:
MetaInfoImpl, MetaInfoImpl_Proxy
Method Summary
boolean included()
java.lang.String name_attribute()
void setIncluded(boolean included)
void setName_attribute(java.lang.String name)
void setTypeName_attribute(java.lang.String name)
java.lang.String typeName_attribute()
MetaInfoGroup.java
cbr
Interface MetaInfoGroup
All Known Implementing Classes:
MetaInfoGroupImpl, MetaInfoGroupImpl_Proxy
106
Estudio para la implementación de un sistema de razonamiento basado en casos
Method Summary
void addMeta(MetaInfoImpl meta)
java.util.ArrayList getMeta()
MetaInfoImpl getMeta(int key)
MetaInfoImpl removeMeta(int key)
MetaInfoGroupImpl.java
cbr
Class MetaInfoGroupImpl
cbr.MetaInfoGroupImpl
All Implemented Interfaces:
MetaInfoGroup
Constructor Summary
MetaInfoGroupImpl()
MetaINfoGroupImpl
Method Summary
void addMeta(MetaInfoImpl meta)
Add metacase at list of MetaCases collection
java.util.ArrayList getMeta()
Add metacase at list of MetaCases collection
MetaInfoImpl getMeta(int key)
Get one metaCase of ArrayList
MetaInfoImpl removeMeta(int key)
Remove metacase of list
MetaInfoImpl.java
cbr
Class MetaInfoImpl
cbr.MetaInfoImpl
All Implemented Interfaces:
MetaInfo
107
Estudio para la implementación de un sistema de razonamiento basado en casos
Constructor Summary
MetaInfoImpl()
MetaInfoImpl
Method Summary
boolean included()
Return included, if is visible or not
java.lang.String name_attribute()
Return name of attribute MetaCase
void setIncluded(boolean included)
Set included
void setName_attribute(java.lang.String name)
Set name of Attribute
void setTypeName_attribute(java.lang.String name)
Set Type of Attribute
java.lang.String typeName_attribute()
Return name of attribute MetaCase
OrdenacionFloat.java
cbr
Class OrdenacionFloat
java.lang.Object
|
+--cbr.OrdenacionFloat
All Implemented Interfaces:
java.util.Comparator
Constructor Summary
OrdenacionFloat()
Method Summary
int compare(java.lang.Object obj1, java.lang.Object obj2)
Compare two objects type Float
OrdenacionInteger.java
cbr
Class OrdenacionInteger
java.lang.Object
|
108
Estudio para la implementación de un sistema de razonamiento basado en casos
+--cbr.OrdenacionInteger
All Implemented Interfaces:
java.util.Comparator
Constructor Summary
OrdenacionInteger()
Method Summary
int compare(java.lang.Object obj1, java.lang.Object obj2)
Compare two objects type Integer
Ordenacion Nombre.java
cbr
Class OrdenacionNombre
java.lang.Object
|
+--cbr.OrdenacionNombre
All Implemented Interfaces:
java.util.Comparator
Constructor Summary
OrdenacionNombre()
Method Summary
int compare(java.lang.Object obj1, java.lang.Object obj2)
Compare two objects type String
OzoneProgram.java
cbr
Class OzoneProgram
java.lang.Object
|
+--cbr.OzoneProgram
109
Estudio para la implementación de un sistema de razonamiento basado en casos
Constructor Summary
OzoneProgram()
Method Summary
static void main(java.lang.String[] args)
main
(package run()
private)
Run,
void
Create main Window
OzoneWindow.java
cbr
Class OzoneWindow
java.lang.Object
|
+--java.awt.Component
|
+--java.awt.Container
|
+--java.awt.Window
|
+--java.awt.Frame
|
+--javax.swing.JFrame
|
+--cbr.OzoneWindow
Constructor Summary
OzoneWindow()
OzoneWindow
Method Summary
void CmdExec(java.lang.String cmdline)
Execute .bat, Code for execute file.bat
(package connectionOzone_actionPerformed(java.awt.event.ActionEvent e)
private)
Connection Database of Ozone
void
(package exit_actionPerformed(java.awt.event.ActionEvent e)
private)
Exit program
void
(package exitWindow(java.awt.event.WindowEvent e)
private)
Exit window
void
(package help_actionPerformed(java.awt.event.ActionEvent e)
110
Estudio para la implementación de un sistema de razonamiento basado en casos
private)
void
help of Aplication
void montar_Menubar()
Create the menubar of ozone Window
(package newCreateDb_actionPerformed(java.awt.event.ActionEvent e)
private)
Create a new Database of Ozone
void
RepositoryOzone.java
cbr
Class RepositoryOzone
java.lang.Object
|
+--cbr.RepositoryOzone
Constructor Summary
RepositoryOzone()
RepositoryOzone
Method Summary
void close()
Close DataBase
void create()
Create Cases from File.dat
void deleteCase(int index)
delete Case in database Ozone
void EditCase(int index, CasesImpl caseObtain)
Edit Case in database Ozone
java.util.ArrayList getCases(javax.swing.JFrame frame)
Get Cases of DataBase
java.util.ArrayList getMeta(javax.swing.JFrame frame)
Get metacases of database
void open()
open dataBase
void saveCaseObtain(CasesImpl caseObtain)
Save Case obtain in database Ozone
void saveDataBase(javax.swing.JFrame frame,
java.util.ArrayList listMeta)
Save metadata case en data base
111
Estudio para la implementación de un sistema de razonamiento basado en casos
ResultsWindow.java
cbr
Class ResultsWindow
java.lang.Object
|
+--java.awt.Component
|
+--java.awt.Container
|
+--javax.swing.JComponent
|
+--javax.swing.JPanel
|
+--cbr.ResultsWindow
Constructor Summary
ResultsWindow(javax.swing.JFrame frameOriginal,
java.util.ArrayList listView, SimilarItems similarItems,
TraitDescriptors traitDescriptors, int maxCases, boolean similarity)
ResultsWindow
Method Summary
void infoTable_action(int row)
Window iformation of one case, Show one case with all Attributes and values
int print(java.awt.Graphics g, java.awt.print.PageFormat pf, int pi)
metod aux
void PrintButton_actionPerformed(java.awt.event.ActionEvent evnt)
Print
void SaveButton_actionPerformed(java.awt.event.ActionEvent e)
Save Cases in file.html
SimilarItems.java
net.sourceforge.selectionengine
Class SimilarItems
java.lang.Object
|
+--net.sourceforge.selectionengine.SimilarItems
Constructor Summary
SimilarItems()
112
Estudio para la implementación de un sistema de razonamiento basado en casos
Method Summary
protected
void add(SimilarityDescription descriptor)
add collection similar items
SimilarityDescription getBestMatch()
return SimilarityDescription, get bestmatch
SimilarItems getBestMatches(int numberOfMatches)
return SimilarItems bestmatches
SimilarItems getByPercentSimilarity(float percentSimilar)
return SimilarItems ByPercentSimilarity
SimilarItems getByRank(int rank)
return SimilarItems ByRank
SimilarityDescription getByRelativeRank(int rank)
return ByRelativeRank
SimilarItems getByThreshold(float minimumPercentSimilar)
return SimilarItems ByThreshold
boolean isEmpty()
return isEmpty
java.util.Iterator iterator()
return iterator
void rankItems()
put rank Items
int size()
return size collection
SimilarityCriteria.java
net.sourceforge.selectionengine
Class SimilarityCriteria
java.lang.Object
|
+--net.sourceforge.selectionengine.SimilarityCriteria
Constructor Summary
SimilarityCriteria()
Method Summary
void add(SimilarityCriterion criterion)
add to collection SimilarCriterion
void add(java.lang.String fieldName,
java.lang.String operator, java.lang.String value)
add to collection SimilarCriterion
java.lang.Object clone()
113
Estudio para la implementación de un sistema de razonamiento basado en casos
Clone object
java.util.Iterator iterator()
Return iterator
protected
void setValues(java.util.ArrayList newValues)
Set values new
int size()
Set integer size of array list
SimilarityCriterion.java
net.sourceforge.selectionengine
Class SimilarityCriterion
java.lang.Object
|
+--net.sourceforge.selectionengine.SimilarityCriterion
Constructor Summary
protected SimilarityCriterion(java.lang.String fieldName,
java.lang.String operator, java.lang.String value)
Method Summary
java.lang.String getFieldName()
Get String Attribute
java.lang.String getID()
Get ID
int getOperator()
Get Operator
java.lang.String getOperatorAsString()
Transform operator As String
TraitValue getValue()
Get trait Value
private operatorToString(int operator)
java.lang.String
Get Special Operator
private
int stringToOperator(java.lang.String operator)
Get Special Operator
SimilarityCriterionScore.java
net.sourceforge.selectionengine
Class SimilarityCriterionScore
java.lang.Object
|
+--net.sourceforge.selectionengine.SimilarityCriterionScore
114
Estudio para la implementación de un sistema de razonamiento basado en casos
Constructor Summary
protected SimilarityCriterionScore(java.lang.String criterionID)
Method Summary
java.lang.String getID()
Get ID "[" + fieldName + "|" + getOperatorAsString() + "|" +
value + "]"
float getNormalizedValue()
Get Normalized value
float getWeightedValue()
Get weight
protected
void setID(java.lang.String criterionID)
Set ID
protected
void setNormalizedValue(float value)
Set Normalized value
protected
void setWeightedValue(float value)
Set Weight
SimilarityCriterionScores.java
net.sourceforge.selectionengine
Class SimilarityCriterionScores
java.lang.Object
|
+--net.sourceforge.selectionengine.SimilarityCriterionScores
Constructor Summary
SimilarityCriterionScores()
Method Summary
void add(SimilarityCriterionScore score)
Add SimilarityCriterionScore at HashMap
SimilarityCriterionScore get(java.lang.String ID)
get SimilarityCriterionScore
java.util.Iterator iterator()
115
Estudio para la implementación de un sistema de razonamiento basado en casos
return Iterator
int size()
return Int
SimilarityDescription.java
net.sourceforge.selectionengine
Class SimilarityDescription
java.lang.Object
|
+--net.sourceforge.selectionengine.SimilarityDescription
Constructor Summary
SimilarityDescription()
Method Summary
int compareTo(java.lang.Object o)
Implements the compareTo method required by the Comparable
interface We're gonna compare items based on their percent similarity Used by
SimilarItems.rankItems() The stupid argument name (o) is Sun's fault, not
mine Return codes: me > arg = -1 (better % match means we go first) me = arg
= 0 me < arg = +1 (it's a better match, it goes first)
Item getItem()
Retun item
float getPercentSimilarity()
Retun PercentSimilarity
int getRank()
Return Integer rank
protected setItem(Item newItem)
void
Set Item
protected setPercentSimilarity(float newPercentMatch)
void
Set percent Similaruty
protected setRank(int newRank)
void
Set Rank
SimilarityEngine.java
net.sourceforge.selectionengine
Class SimilarityEngine
java.lang.Object
|
+--net.sourceforge.selectionengine.SimilarityEngine
116
Estudio para la implementación de un sistema de razonamiento basado en casos
Constructor Summary
SimilarityEngine()
Method Summary
private
float computeDistance(SimilarityCriterionScores
targetValues,
SimilarityCriterionScores itemValues)
Get compute Distance between Target values and Item
values
SimilarItems computeSimilarity(Items items,
SimilarityCriteria criteria,
SimilarityWeights weights)
compute similarity and return the similar items
SimilarItems computeSimilarity(Items items,
SimilarityCriteria criteria,
SimilarityWeights weights,
DataSetStatistics statistics)
compute similarity and return the similar items
private
float getMaxDistance(SimilarityCriteria criteria,
SimilarityWeights weights)
To compute how similar two items are,
we first create a single-dimensional range from 0
to some max distance number.
private getTargetValues
SimilarityCriterionScores (TraitDescriptors traitDescriptors,
SimilarityCriteria criteria,
SimilarityWeights weights,
DataSetStatistics statistics)
Get values of the case target
private normalizeValues(Item item,
SimilarityCriterionScores SimilarityCriteria criteria,
SimilarityWeights weights,
DataSetStatistics statistics)
Nomralized values of item
SimilarityWeight.java
net.sourceforge.selectionengine
Class SimilarityWeight
java.lang.Object
|
+--net.sourceforge.selectionengine.SimilarityWeight
117
Estudio para la implementación de un sistema de razonamiento basado en casos
Constructor Summary
SimilarityWeight(java.lang.String fieldName, java.lang.Integer weight)
set Attribute and Weigth
Method Summary
java.lang.String getFieldName()
Return Attribute
java.lang.Integer getWeight()
Return Weight
SimilarityWeights.java
net.sourceforge.selectionengine
Class SimilarityWeights
java.lang.Object
|
+--net.sourceforge.selectionengine.SimilarityWeights
Constructor Summary
SimilarityWeights()
Method Summary
void add(java.lang.String fieldName, int weight)
Add HashMap Weights
java.lang.Object clone()
Clone Object
int get(java.lang.String traitName)
return Integer Value Weight from attribute
java.util.Iterator iterator()
Return iterator
java.util.Iterator mapIterator()
Return Iterator
private
void setValues(java.util.HashMap newValues)
setValues hashmap
int size()
return Size of Weights
118
Estudio para la implementación de un sistema de razonamiento basado en casos
Trait.java
net.sourceforge.selectionengine
Class Trait
java.lang.Object
|
+--net.sourceforge.selectionengine.Trait
Constructor Summary
protected Trait(java.lang.String name, java.lang.String value)
Set Name attribute & value
Method Summary
java.lang.String getName()
Return Name of Attribute
TraitValue getValue()
Return Value of Attribute
protected
void setName(java.lang.String newName)
Set Name attribute
protected
void setValue(java.lang.String newValue)
Set value of attribute
TraitDescriptor.java
net.sourceforge.selectionengine
Class TraitDescriptor
java.lang.Object
|
+--net.sourceforge.selectionengine.TraitDescriptor
Constructor Summary
(package TraitDescriptor(java.lang.String name, java.lang.String type,
private) boolean included)
Construct traitDescriptor
Method Summary
int getDataType()
Return DataType
boolean getIncluded()
Return is visible?
119
Estudio para la implementación de un sistema de razonamiento basado en casos
java.lang.String getName()
Return Name Attribute
int obtainDataType(java.lang.String dataType)
private
Return Numeric value
int stringToDataType(java.lang.String dataType)
private
Return Numeric value
java.lang.String toString()
TraitDescriptors.java
net.sourceforge.selectionengine
Class TraitDescriptors
java.lang.Object
|
+--net.sourceforge.selectionengine.TraitDescriptors
Constructor Summary
TraitDescriptors()
Method Summary
private
void add(int index, TraitDescriptor descriptor)
add traitDescriptor to collection
TraitDescriptor get(int index)
TraitDescriptor get(java.lang.String traitName)
int getDataType(java.lang.String traitName)
boolean isEmpty()
is empty collection?
java.util.Iterator iterator()
protected
void loadTraitDescriptorOfCase(java.util.ArrayList listMeta)
int size()
TraitPanel.java
cbr
Class TraitPanel
java.lang.Object
120
Estudio para la implementación de un sistema de razonamiento basado en casos
|
+--java.awt.Component
|
+--java.awt.Container
|
+--javax.swing.JComponent
|
+--javax.swing.JPanel
|
+--cbr.TraitPanel
Constructor Summary
TraitPanel()
Method Summary
javax.swing.JCheckBox getFilterCheckBox()
Return filterCheckBox
java.lang.String getFilterOperator()
get FilterOperator
javax.swing.JComboBox getFilterOperatorComboBox()
get JcomboBox
java.lang.String getFilterValue()
return String Valuefilter
javax.swing.JComboBox getFilterValueComboBox()
getFilterValueComboBox
java.lang.String getPreferenceValue()
getPreferenceValue
javax.swing.JComboBox getPreferenceValueComboBox()
getPreferenceValueComboBox
javax.swing.JCheckBox getSimilarityCheckBox()
Return JCheckBox of Similarity
int getTraitDataType()
get Datatype of attribute
java.lang.String getTraitName()
Return name Attribute
javax.swing.ButtonGroup getValueButtonGroup()
getValueButtonGroup
int getWeight()
getWeight
javax.swing.ButtonGroup getWeightButtonGroup()
getWeightButtonGroup
boolean hasFilterCriteria()
return hasFilterCriteria
boolean hasSimilarityCriteria()
return hasSimilarityCriteria
121
Estudio para la implementación de un sistema de razonamiento basado en casos
void setFilterCheckBox
(javax.swing.JCheckBox filterCheckBox)
set filterCheckBox asign JCheckBox
void setFilterOperatorComboBox
(javax.swing.JComboBox list)
set FilterOperatorComboBox
void setFilterValueComboBox
(javax.swing.JComboBox list)
getFilterValueComboBox
void setPreferenceValueComboBox
(javax.swing.JComboBox list)
setPreferenceValueComboBox
void setSimilarityCheckBox
(javax.swing.JCheckBox preferCheckBox)
Set Similarity CheckBox
void setTraitDataType(int dataType)
set TraitDataType
void setTraitName(java.lang.String name)
Set traitName os attribute
void setValueButtonGroup
(javax.swing.ButtonGroup group)
setValueButtonGroup
void setWeightButtonGroup
(javax.swing.ButtonGroup group)
setWeightButtonGroup
Traits.java
net.sourceforge.selectionengine
Class Traits
java.lang.Object
|
+--net.sourceforge.selectionengine.Traits
Method Summary
protected
void add(Trait newTrait)
Insert objects Trait in hasMap for rapid accesvkey for insert is
name Attribute
Trait get(java.lang.String traitName)
return object trait
boolean isEmpty()
Return boolean if Traits is Empty
java.util.Iterator iterator()
Return iterator of values Traits
protected
void loadFromDelimitedCase(TraitDescriptors traitDescriptors,
java.util.ArrayList caseItem)
Load data from a string The string will have the data fields in
122
Estudio para la implementación de un sistema de razonamiento basado en casos
the same order as the array of field definitions The string is |
delimited
TraitStatistics.java
net.sourceforge.selectionengine
Class TraitStatistics
java.lang.Object
|
+--net.sourceforge.selectionengine.TraitStatistics
Constructor Summary
TraitStatistics(java.lang.String traitName)
Method Summary
void addExample(float value)
Put minimum value and maximun value
float getMaximumValue()
return Maximun value
float getMinimumValue()
return minimum
float getRange()
return get range (maxvalue - minvalue)
java.lang.String getTraitName()
return name trait
protected
void setMaximumValue(float value)
set max value
protected
void setMinimumValue(float value)
set min value
protected
void setTraitName(java.lang.String name)
set traitname
TraitValue.java
net.sourceforge.selectionengine
Class TraitValue
java.lang.Object
|
+--net.sourceforge.selectionengine.TraitValue
123
Estudio para la implementación de un sistema de razonamiento basado en casos
Constructor Summary
TraitValue(java.lang.String value)
Method Summary
boolean toBoolean()
return Boolean value
float toFloat()
return Float value
int toInteger()
return integer value
java.lang.String toString()
return String value
java.lang.String value()
return String value
WindowCaseDelete.java
cbr
Class WindowCaseDelete
java.lang.Object
|
+--java.awt.Component
|
+--java.awt.Container
|
+--javax.swing.JComponent
|
+--javax.swing.JPanel
|
+--cbr.WindowCaseDelete
Constructor Summary
WindowCaseDelete(javax.swing.JFrame frameOriginal,
java.util.ArrayList listMeta, java.util.Hashtable casesAcces,
java.util.ArrayList list, java.lang.String code, CasesImpl caseObtain,
RepositoryOzone ozoneRepository)
WindowCaseDelete
Method Summary
void deleteButton_actionPerformed(java.awt.event.ActionEvent e,
RepositoryOzone ozoneRepository, javax.swing.JDialog dialog)
Action boton Delete case, delete case from database
124
Estudio para la implementación de un sistema de razonamiento basado en casos
WindowCaseEdit.java
cbr
Class WindowCaseEdit
java.lang.Object
|
+--java.awt.Component
|
+--java.awt.Container
|
+--javax.swing.JComponent
|
+--javax.swing.JPanel
|
+--cbr.WindowCaseEdit
Constructor Summary
WindowCaseEdit(javax.swing.JFrame frameOriginal,
java.util.ArrayList listMeta, java.util.Hashtable casesAcces,
java.util.ArrayList listCases, java.lang.String code,
CasesImpl caseObtain, RepositoryOzone ozoneRepository)
WindowCaseEdit
Method Summary
void SaveButton_actionPerformed(java.awt.event.ActionEvent e,
java.util.Vector data, RepositoryOzone ozoneRepository,
javax.swing.JDialog dialog)
Action boton Save case
WindowCaseNew.java
cbr
Class WindowCaseNew
java.lang.Object
|
+--java.awt.Component
|
+--java.awt.Container
|
+--javax.swing.JComponent
|
+--javax.swing.JPanel
|
+--cbr.WindowCaseNew
Constructor Summary
WindowCaseNew(javax.swing.JFrame frameOriginal,
java.util.ArrayList listMeta, java.util.Hashtable casesAcces,
java.util.ArrayList listCases, RepositoryOzone ozoneRepository)
WindowCaseNew
125
Estudio para la implementación de un sistema de razonamiento basado en casos
Method Summary
void SaveButton_actionPerformed(java.awt.event.ActionEvent e,
java.util.Vector data, RepositoryOzone ozoneRepository,
javax.swing.JDialog dialog)
Action boton Save case
WindowCasesInfo.java
cbr
Class WindowCasesInfo
java.lang.Object
|
+--java.awt.Component
|
+--java.awt.Container
|
+--javax.swing.JComponent
|
+--javax.swing.JPanel
|
+--cbr.WindowCasesInfo
Constructor Summary
WindowCasesInfo(int rank, SimilarItems similarItems,
TraitDescriptors traitDescriptors)
WindowCasesInfo
WindowCaseView.java
cbr
Class WindowCaseView
java.lang.Object
|
+--java.awt.Component
|
+--java.awt.Container
|
+--javax.swing.JComponent
|
+--javax.swing.JPanel
|
+--cbr.WindowCaseView
Constructor Summary
WindowCaseView(javax.swing.JFrame frameOriginal,
java.util.ArrayList listMeta, java.util.ArrayList list)
WindowCaseView
126
Estudio para la implementación de un sistema de razonamiento basado en casos
WindowMetaDataCase.java
cbr
Class WindowMetaDataCase
java.lang.Object
|
+--java.awt.Component
|
+--java.awt.Container
|
+--javax.swing.JComponent
|
+--javax.swing.JPanel
|
+--cbr.WindowMetaDataCase
Constructor Summary
WindowMetaDataCase(javax.swing.JFrame frameOriginal,
java.util.ArrayList listMeta, java.util.ArrayList list,
javax.swing.JMenuItem newFind, javax.swing.JMenuItem viewList,
javax.swing.JMenuItem insertCase, javax.swing.JMenuItem editCase,
javax.swing.JMenuItem deleteCase, javax.swing.JMenuItem metaDataOpCase,
javax.swing.JMenuItem maxCasesView)
WindowMetadataCase, Create window for insert metadata
Method Summary
void addButton_actionPerformed(java.awt.event.ActionEvent e)
Action Buton add Attribute defined
void deleteAttribute_actionPerformed(java.awt.event.ActionEvent e)
Action Buton detele meta Attribute
void okButton_actionPerformed(java.awt.event.ActionEvent e,
java.util.ArrayList listMeta, java.util.ArrayList list,
javax.swing.JDialog dialog)
Action Buton save metadata, list of metadata complete
127
Estudio para la implementación de un sistema de razonamiento basado en casos
WindowProgressBarReload.java
cbr
Class WindowProgressBarReload
java.lang.Object
|
+--java.awt.Component
|
+--java.awt.Container
|
+--javax.swing.JComponent
|
+--javax.swing.JPanel
|
+--cbr.WindowProgressBarReload
Constructor Summary
WindowProgressBarReload(javax.swing.JFrame frameOriginal,
java.util.Hashtable casesAcces, java.util.ArrayList list)
WindowprogressbarReload
128
Estudio para la implementación de un sistema de razonamiento basado en casos
Apéndice C. Código CBR Extraction Module
*******************************************************************************************
Cases.java
*******************************************************************************************
/**
Interface used by ozone casebase for define the methods for Cases objects,
Programmer: Manuel Miguel Gimenez Arjona
Proyect:CBR Extraccion Module
Directors: Ivan Lopez Arevalo / Aïda Valls Mateu
Departament de Enginyeria Informatica i Matematiques
Universitat Rovira i Virgili
Date: 2.08.2005
*/
package cbr;
import org.ozoneDB.OzoneRemote;
import java.util.*;
import java.io.*;
public interface Cases extends OzoneRemote {
public ArrayList list();
public void setList( ArrayList list ); /*update*/
}
*******************************************************************************************
CasesGroup.java
*******************************************************************************************
/**
Interface used by ozone casebase for define the methods for CasesGoup objects,
Programmer: Manuel Miguel Gimenez Arjona
Proyect:CBR Extraccion Module
Directors: Ivan Lopez Arevalo / Aïda Valls Mateu
Departament de Enginyeria Informatica i Matematiques
Universitat Rovira i Virgili
Date: 2.08.2005
*/
package cbr;
import org.ozoneDB.OzoneRemote;
import java.util.*;
public interface CasesGroup extends OzoneRemote {
public void addCases (CasesImpl cases) throws Exception; /*update*/
public ArrayList getCases();
public CasesImpl getCases( int key );
public void removeCases( int key ); /*update*/
public void insertCase( int key, CasesImpl cases ) ; /*update*/
}
*******************************************************************************************
129
Estudio para la implementación de un sistema de razonamiento basado en casos
CasesGroupImpl.java
*******************************************************************************************
/**
Class implements CasesGroup. This class saves a collection of cases object
Programmer: Manuel Miguel Gimenez Arjona
Proyect:CBR Extraccion Module
Directors: Ivan Lopez Arevalo / Aïda Valls Mateu
Departament de Enginyeria Informatica i Matematiques
Universitat Rovira i Virgili
Date: 2.08.2005
*/
package cbr;
import org.ozoneDB.OzoneObject;
import java.util.*;
public class CasesGroupImpl extends OzoneObject implements CasesGroup {
final static long serialVersionUID = 1L;
private ArrayList cases;// = new Hashtable();
private int numCases = 0;
/**CasesGroupImpl
* @param Not param
* @exception Not Exceptions
*/
public CasesGroupImpl() {
//units es la Coleccion de units de la funcion
cases = new ArrayList();
}
/**Add cases to ArrayList of Cases
* @param CasesImpl Cases, Case for add
* @exception Error
*/
public void addCases(CasesImpl cases) throws Exception {
try{
this.cases.add(numCases,cases);
numCases = numCases + 1;
} catch(Exception e){
System.out.println("Error at CasesGroupImpl::addCases() "+e);
}
}
/**Rutun Cases
* @return Return ArrayList of Cases
* @exception Not Exceptions
*/
public ArrayList getCases() {
return this.cases;
}
/**Return a Case of Cases
* @param int Key, Integer of position Case
* @return CasesImpl
* @exception Not Exceptions
*/
public CasesImpl getCases( int key ) {
return (CasesImpl)this.cases.get( key );
}
130
Estudio para la implementación de un sistema de razonamiento basado en casos
/**Return Cases without case
* @param int Key, Integer of position Case
* @return CasesImpl
* @exception Not Exceptions
*/
public void removeCases( int key ) {
numCases = numCases - 1;
this.cases.remove( key );
}
/**Insert Case in list
* @param int Key, Integer of position Case
* @param CasesImpl cases, Case insert
* @exception Not Exceptions
*/
public void insertCase( int key, CasesImpl cases ) {
this.cases.remove(key);
this.cases.add(key,cases);
}
}
*******************************************************************************************
CasesImpl.java
*******************************************************************************************
/**
Class implements Cases. This class asociate Array list with all values
of a case
Programmer: Manuel Miguel Gimenez Arjona
Proyect:CBR Extraccion Module
Directors: Ivan Lopez Arevalo / Aïda Valls Mateu
Departament de Enginyeria Informatica i Matematiques
Universitat Rovira i Virgili
Date: 2.08.2005
*/
package cbr;
import org.ozoneDB.OzoneObject;
import java.util.*;
import java.io.*;
public class CasesImpl extends OzoneObject implements Cases {
final static long serialVersionUID = 1L;
ArrayList list = new ArrayList();
/**CasesImpl
* @param Not Param
* @return CasesImpl
* @exception Not Exceptions
*/
public CasesImpl() {
}
/**Return a list of Attributes of case
* @param Not Param
* @return ArrayList list of attributes
* @exception Not Exceptions
*/
public ArrayList list() {
return list;
}
131
Estudio para la implementación de un sistema de razonamiento basado en casos
/**Set List
* @param ArrayList list, list
* @return ArrayList list of attributes
* @exception Not Exceptions
*/
public void setList( ArrayList list ) {
this.list = list;
}
}
*******************************************************************************************
CBRProgram.java
*******************************************************************************************
/**
Class Implement main, Class for launch aplication CBR EXTRACCION MODULE
Programmer: Manuel Miguel Gimenez Arjona
Proyect:CBR Extraccion Module
Directors: Ivan Lopez Arevalo / Aïda Valls Mateu
Departament de Enginyeria Informatica i Matematiques
Universitat Rovira i Virgili
Date: 2.08.2005
*/
package cbr;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.util.*;
import java.io.*;
public class CBRProgram {
/** Main of Program
*/
public static void main(String[] args) {
CBRProgram application = new CBRProgram();
application.run();
}
/** Metod run for create Desktop Environment of Aplication
* @param Not param
* @exception Not exceptions
*/
void run() {
int width=1003, height=670; //dimension window
CBRWindow mainWindow = new CBRWindow();
Dimension sizePant=Toolkit.getDefaultToolkit().getScreenSize();
mainWindow.setLocation( (sizePant.width - width) / 2,
(sizePant.height - height) / 2);
mainWindow.setTitle("Extraction Module CBR");
mainWindow.setResizable(false);
mainWindow.setSize(width,height);
mainWindow.show();
}
}
*******************************************************************************************
CBRProgram.java
*******************************************************************************************
132
Estudio para la implementación de un sistema de razonamiento basado en casos
/**
Class CBRWindow, Class principal window of de CRB Extraction module,
This class
management Data base options , insert new case, edit case, delete
case, show all cases
metadatacase insert and find similar cases thanks to the module of
selection Engine proyect,
Programmer: Manuel Miguel Gimenez Arjona
Proyect:CBR Extraccion Module
Directors: Ivan Lopez Arevalo / Aïda Valls Mateu
Departament de Enginyeria Informatica i Matematiques
Universitat Rovira i Virgili
Date: 2.08.2005
*/
package cbr;
import java.io.*;
import java.awt.*;
import java.util.*;
import javax.swing.*;
import java.awt.event.*;
import javax.swing.table.*;
import javax.swing.event.*;
import javax.swing.border.*;
import net.sourceforge.selectionengine.SimilarityCriteria;
import net.sourceforge.selectionengine.SimilarityWeights;
import net.sourceforge.selectionengine.FilterCriteria;
import net.sourceforge.selectionengine.FilterEngine;
import net.sourceforge.selectionengine.Items;
import net.sourceforge.selectionengine.ItemManager;
import net.sourceforge.selectionengine.DataSetStatistics;
import net.sourceforge.selectionengine.SimilarItems;
import net.sourceforge.selectionengine.SimilarityEngine;
public class CBRWindow extends JFrame{
public
public
public
public
static
static
static
static
final
final
final
final
int
int
int
int
TYPE_BOOLEAN
TYPE_FLOAT
TYPE_INTEGER
TYPE_STRING
=
=
=
=
1;
2;
3;
4;
RepositoryOzone ozoneRepository; // repository Ozone CaseBase
Conection
int maxCases = 30; // max show similarity cases
Items items = null;
MetaInfoImpl metaInfoNew;
CasesImpl casesNew;
boolean SearchSimil = false;
boolean listener = false;
Hashtable casesAcces = new Hashtable();
ArrayList list = new ArrayList(); // list of cases
ArrayList listMeta = new ArrayList(); // list of metacases
// JPanels for window query
JPanel titlePanel;
JPanel panelMain;
JPanel headerLinePanel;
JPanel panel1, panel2, panel3, panel4, panel5, panel6, panel7;
JPanel buttonPanel = new JPanel();
JPanel imagePanel = new JPanel();
// JRadioButtons for window query
JRadioButton jRadioButton1, jRadioButton2, jRadioButton3,
jRadioButton4, jRadioButton5;
JRadioButton jRadioButton6, jRadioButton7, jRadioButton8,
jRadioButton9, jRadioButton10;
133
Estudio para la implementación de un sistema de razonamiento basado en casos
TraitPanel commonPanel;
ButtonGroup ImportanceGroup;
// Jcombobox for window query
JComboBox FilterComboBox;
JComboBox OperatorComboBox;
JComboBox SimilarityComboBox;
// Jlavels for window query
JLabel jLabel1, jLabel2, jLabel3, jLabel4, jLabel5, fillLabel = new
JLabel("");
// JCheckBox for window query
JCheckBox PreferCheckBox;
JCheckBox FilterCheckBox;
// JScrollPane for window query
JScrollPane queryScrollPane;
JButton submitButton = new JButton();
JButton cancelButton = new JButton();
// JMenuBar & JMenu for Aplication
JMenuBar menuOp = new JMenuBar();
JMenu menuFile = new JMenu ("File");
JMenu menuEdit = new JMenu ("Edit");
JMenu menuSearch = new JMenu ("Search");
JMenu menuView = new JMenu ("View"); // resice
JMenu menuHelp = new JMenu ("Help");
// JMenuItem for JMenubar
JMenuItem openDb = new JMenuItem("Connect DB Ozone");
JMenuItem disConnectionOzone = new JMenuItem("Close DB
Ozone");
JMenuItem metaDataOpCase = new JMenuItem("Metadata Case");
JMenuItem insertCase = new JMenuItem("Insert Case");
JMenuItem editCase = new JMenuItem("Edit Case");
JMenuItem deleteCase = new JMenuItem("Delete Case");
JMenuItem maxCasesView = new JMenuItem("View Max similar Cases
");
JMenuItem newFind = new JMenuItem("New Search Similarity");
JMenuItem viewList = new JMenuItem("Show all Cases");
JMenuItem help = new JMenuItem("Help");
JMenuItem exit = new JMenuItem("Exit Program");
/** CBRWindow Inciate Window, build MenuBar, options & images
* @param Not param
* @exception printStackTrace e, RuntimeException
*/
public CBRWindow() {
try {
montar_Menubar(); // buid Menubar of aplication
ImageIcon imagen= new ImageIcon ("images/Dibujo.jpg");
JLabel label = new JLabel(imagen);
this.getContentPane().add(label);
}
catch(Exception e) {
e.printStackTrace();
}
}
/** Iniciate new search similar attributes
* @param Not param
* @exception printStackTrace e, RuntimeException
*/
public void iniciateQuery() {
try {
loadItems(); // load items in Selection Engine
init(); // Iniciate window query
}
134
Estudio para la implementación de un sistema de razonamiento basado en casos
catch(Exception e) {
e.printStackTrace();
}
}
/** Iniciate Window query with attributes CaseBase and criterion search
* @param Not param
* @exception Not Exception
*/
private void init() {
int indexAttribute = 0;
Iterator itOrd;
ArrayList listOrd;
SearchSimil = true; // window query activate
//Serial Components Window
titlePanel = new JPanel();
ImageIcon imagen= new ImageIcon ("images/DibujoNewSearch.jpg");
// optional image
JLabel labelTitle = new JLabel(imagen);
// Gruup panel with panels
// ATTIBUTE,PREFER, PREFER VALUE, IMPORTANCE, REQUIRE,
OPERATOR,REQUIRE VALUE
headerLinePanel = new JPanel();
headerLinePanel.setLayout(new GridLayout(0,7));
headerLinePanel.setPreferredSize(new Dimension(345,30)); //945
headerLinePanel.setBorder(BorderFactory.createEtchedBorder());
// JPanels
panel1 = new JPanel();
panel2 = new JPanel();
JPanel();
panel4 = new JPanel();
panel5 = new JPanel();
JPanel(); panel7 = new JPanel();
panel3 = new
panel6 = new
panel1.setBorder(BorderFactory.createEtchedBorder());
panel2.setBorder(BorderFactory.createEtchedBorder());
panel3.setBorder(BorderFactory.createEtchedBorder());
panel4.setBorder(BorderFactory.createEtchedBorder());
panel5.setBorder(BorderFactory.createEtchedBorder());
panel6.setBorder(BorderFactory.createEtchedBorder());
panel7.setBorder(BorderFactory.createEtchedBorder());
panel1.add( new JLabel("ATTRIBUTE") );
panel2.add( new
JLabel("PREFER") );
panel3.add( new JLabel("PREFER VALUE") ); panel4.add( new
JLabel("IMPORTANCE") );
panel5.add( new JLabel("REQUIRE") );
panel6.add( new
JLabel("OPERATOR") );
panel7.add( new JLabel("REQUIRE VALUE") );
headerLinePanel.add(
headerLinePanel.add(
headerLinePanel.add(
headerLinePanel.add(
panel1
panel3
panel5
panel7
);
);
);
);
headerLinePanel.add( panel2 );
headerLinePanel.add( panel4 );
headerLinePanel.add( panel6 );
panelMain = new JPanel();
panelMain.add(headerLinePanel);
//end main components Window
Iterator it = this.listMeta.iterator();
Iterator itCases = this.list.iterator();
//Components Window attributes visibles
while (it.hasNext()) { // while exist Attributes defined
metaInfoNew = (MetaInfoImpl)it.next();
if (metaInfoNew.included() == true){ // Attribute is
visible?
135
Estudio para la implementación de un sistema de razonamiento basado en casos
commonPanel = new TraitPanel();
jLabel1 = new JLabel();
jLabel1.setPreferredSize(new Dimension(100, 17));
jLabel1.setHorizontalAlignment(SwingConstants.CENTER);
jLabel1.setText(metaInfoNew.name_attribute());
PreferCheckBox = new JCheckBox();
//importance
jRadioButton1 = new JRadioButton();
jRadioButton1.setActionCommand("1");
jRadioButton1.setHorizontalAlignment(SwingConstants.CENTER);
jRadioButton1.setText("-");
jRadioButton1.setHorizontalTextPosition(SwingConstants.CENTER);
jRadioButton1.setVerticalTextPosition(SwingConstants.BOTTOM);
jRadioButton2 = new JRadioButton();
jRadioButton2.setActionCommand(" 2");
jRadioButton2.setVerticalTextPosition(SwingConstants.BOTTOM);
jRadioButton2.setText(" ");
jRadioButton2.setHorizontalTextPosition(SwingConstants.CENTER);
jRadioButton2.setHorizontalAlignment(SwingConstants.CENTER);
jRadioButton3 = new JRadioButton();
jRadioButton3.setActionCommand(" 3");
jRadioButton3.setHorizontalAlignment(SwingConstants.CENTER);
jRadioButton3.setText(" ");
jRadioButton3.setSelected(true);
jRadioButton3.setHorizontalTextPosition(SwingConstants.CENTER);
jRadioButton3.setVerticalTextPosition(SwingConstants.BOTTOM);
jRadioButton4 = new JRadioButton();
jRadioButton4.setActionCommand(" 4");
jRadioButton4.setHorizontalAlignment(SwingConstants.CENTER);
jRadioButton4.setText(" ");
jRadioButton4.setHorizontalTextPosition(SwingConstants.CENTER);
jRadioButton4.setVerticalTextPosition(SwingConstants.BOTTOM);
jRadioButton5 = new JRadioButton();
jRadioButton5.setActionCommand("5");
jRadioButton5.setHorizontalAlignment(SwingConstants.CENTER);
jRadioButton5.setText("+");
jRadioButton5.setHorizontalTextPosition(SwingConstants.CENTER);
jRadioButton5.setVerticalTextPosition(SwingConstants.BOTTOM);
ImportanceGroup = new ButtonGroup();
ImportanceGroup.add(jRadioButton1);
ImportanceGroup.add(jRadioButton2);
ImportanceGroup.add(jRadioButton3);
ImportanceGroup.add(jRadioButton4);
ImportanceGroup.add(jRadioButton5);
//combobox
FilterComboBox = new JComboBox();
OperatorComboBox = new JComboBox();
SimilarityComboBox = new JComboBox();
OperatorComboBox.setPreferredSize(new Dimension(70, 20));
SimilarityComboBox.setPreferredSize(new Dimension(120, 20));
FilterComboBox.setPreferredSize(new Dimension(120, 20));
commonPanel.setLayout(new GridLayout(0,7));
commonPanel.setBorder(BorderFactory.createEtchedBorder());
FilterCheckBox = new JCheckBox();
commonPanel.setTraitName(metaInfoNew.name_attribute());
String typeAttribute = metaInfoNew.typeName_attribute(); // Type of data
//Type of attibute in commonPanel
if (typeAttribute.equals("String")){
commonPanel.setTraitDataType(TYPE_STRING);
}else if(typeAttribute.equals("Boolean")){
commonPanel.setTraitDataType(TYPE_BOOLEAN);
}else if(typeAttribute.equals("Float")){
commonPanel.setTraitDataType(TYPE_FLOAT);
136
Estudio para la implementación de un sistema de razonamiento basado en casos
}else if(typeAttribute.equals("Integer")){
commonPanel.setTraitDataType(TYPE_INTEGER);
}
commonPanel.setFilterOperatorComboBox(OperatorComboBox);
commonPanel.setFilterValueComboBox(FilterComboBox);
commonPanel.setPreferenceValueComboBox(SimilarityComboBox);
commonPanel.setWeightButtonGroup(ImportanceGroup);
commonPanel.setFilterCheckBox(FilterCheckBox);
commonPanel.setSimilarityCheckBox(PreferCheckBox);
// JPanels For objects
panel1 = new JPanel();
panel4 = new JPanel();
panel7 = new JPanel();
panel2 = new JPanel();
panel5 = new JPanel();
panel3 = new JPanel();
panel6 = new JPanel();
panel1.add(jLabel1);
panel2.add(PreferCheckBox);
panel3.add(SimilarityComboBox);
panel4.add(jRadioButton1); panel4.add(jRadioButton2);
panel4.add(jRadioButton3);
panel4.add(jRadioButton4); panel4.add(jRadioButton5);
panel5.add(FilterCheckBox);
panel6.add(OperatorComboBox);
panel7.add(FilterComboBox);
panel1.setBorder(BorderFactory.createEtchedBorder());
panel2.setBorder(BorderFactory.createEtchedBorder());
panel3.setBorder(BorderFactory.createEtchedBorder());
panel4.setBorder(BorderFactory.createEtchedBorder());
panel5.setBorder(BorderFactory.createEtchedBorder());
panel6.setBorder(BorderFactory.createEtchedBorder());
panel7.setBorder(BorderFactory.createEtchedBorder());
commonPanel.add(panel1);
commonPanel.add(panel2);
commonPanel.add(panel3);
commonPanel.add(panel4);
commonPanel.add(panel5);
commonPanel.add(panel6);
commonPanel.add(panel7);
// Main Panel
panelMain.add(commonPanel);
//Combobox list arranged according type Data
listOrd = Ordenacion(ItemsCombobox(indexAttribute),
typeAttribute);
itOrd = listOrd.iterator();
while( itOrd.hasNext() ){ // while exist information add to
if (typeAttribute.equals("String")){
String attribute = (String)itOrd.next();
SimilarityComboBox.addItem(attribute);
FilterComboBox.addItem(attribute);
}else if (typeAttribute.equals("Integer")){
Integer attributeInt = (Integer)itOrd.next();
SimilarityComboBox.addItem(attributeInt);
FilterComboBox.addItem(attributeInt);
}else if (typeAttribute.equals("Float")){
Float attributeFloat = (Float)itOrd.next();
SimilarityComboBox.addItem(attributeFloat);
FilterComboBox.addItem(attributeFloat);
}else{
String attribute = (String)itOrd.next();
SimilarityComboBox.addItem(attribute);
FilterComboBox.addItem(attribute);
}
}
// Operators Combobox according Type Data(numeric,Not Numeric, boolean)
if (typeAttribute.equals("String")){
addNonNumericFilterOperators(OperatorComboBox);
137
Estudio para la implementación de un sistema de razonamiento basado en casos
}else if(typeAttribute.equals("Boolean")){
addBooleanFilterOperators(OperatorComboBox);
}else{
addNumericFilterOperators(OperatorComboBox);
}
}
indexAttribute++; // increment index of Attribute
}
panelMain.setLayout(new GridLayout(0,1));
queryScrollPane = new JScrollPane();
queryScrollPane.setBorder(BorderFactory.createLoweredBevelBorder());
queryScrollPane.getViewport().add(panelMain, null);
// buttons Window (cancel and show similar cases)
submitButton.setText("Get similar cases");
cancelButton.setText("Cancel");
submitButton.setBounds(100,20,100,20);
cancelButton.setBounds(100,20,100,20);
buttonPanel.add(cancelButton, null);
buttonPanel.add(submitButton, null);
this.getContentPane().setVisible(false);
this.getContentPane().removeAll();
this.getContentPane().add(labelTitle,BorderLayout.NORTH);
this.getContentPane().add(queryScrollPane, BorderLayout.CENTER);
this.getContentPane().add(buttonPanel, BorderLayout.SOUTH);
this.getContentPane().setVisible(true);
// ActionListeners for buttons
if (listener == false){
cancelButton.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(ActionEvent e)
{
cancelButton_actionPerformed();
} });
submitButton.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(ActionEvent e)
{
submitButton_actionPerformed(e);
} });
listener = true;
}
}
/** Iniciate MenuBar of Aplication & Submenus
* @param Not param
* @exception Not Exception
*/
public void montar_Menubar (){
// GROUPS
// Group Menubar menuFile
menuFile.setMnemonic(KeyEvent.VK_F);
openDb.setMnemonic(KeyEvent.VK_C);
menuFile.add(openDb);
138
Estudio para la implementación de un sistema de razonamiento basado en casos
disConnectionOzone.setMnemonic(KeyEvent.VK_S);
menuFile.add(disConnectionOzone);
disConnectionOzone.setEnabled(false);
exit.setMnemonic(KeyEvent.VK_X);
menuFile.add(new JSeparator());
menuFile.add(exit);
// Group Edit
menuEdit.setMnemonic(KeyEvent.VK_E);
metaDataOpCase.setMnemonic(KeyEvent.VK_M);
metaDataOpCase.setEnabled(false); menuEdit.add(metaDataOpCase);
insertCase.setMnemonic(KeyEvent.VK_I);
insertCase.setEnabled(false);
menuEdit.add(insertCase);
editCase.setMnemonic(KeyEvent.VK_T);
editCase.setEnabled(false);
menuEdit.add(editCase);
deleteCase.setMnemonic(KeyEvent.VK_L);
deleteCase.setEnabled(false);
menuEdit.add(deleteCase);
// Group Search
menuSearch.setMnemonic(KeyEvent.VK_M);
newFind.setMnemonic(KeyEvent.VK_N);
newFind.setEnabled(false);
menuSearch.add(newFind);
// Group ViewList
menuView.setMnemonic(KeyEvent.VK_V);
viewList.setMnemonic(KeyEvent.VK_S);
maxCasesView.setMnemonic(KeyEvent.VK_A);
maxCasesView.setEnabled(false);
viewList.setEnabled(false);
menuView.add(viewList);
menuView.add(maxCasesView);
// Group Help
menuHelp.add(help);
// All Groups
menuOp.add(menuFile);
menuOp.add(menuEdit);
menuOp.add(menuSearch);
menuOp.add(menuView);
menuOp.add(menuHelp);
// LISTENERS
// Event Help
help.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(ActionEvent e) {
help_actionPerformed(e);
}});
// Event metaDataCase
metaDataOpCase.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(ActionEvent e) {
metaDataOpCase_actionPerformed(e);
}});
// Event New Find
newFind.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(ActionEvent e) {
newfind_actionPerformed(e);
}});
// Insert Case
insertCase.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(ActionEvent e) {
insertCase_actionPerformed(e);
}});
// Edit Case
editCase.addActionListener(new java.awt.event.ActionListener() {
139
Estudio para la implementación de un sistema de razonamiento basado en casos
public void actionPerformed(ActionEvent e) {
editCase_actionPerformed(e);
}});
// Delete Case
deleteCase.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(ActionEvent e) {
deleteCase_actionPerformed(e);
}});
// View Case
viewList.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(ActionEvent e) {
viewList_actionPerformed(e);
}});
// view max similar cases
maxCasesView.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(ActionEvent e) {
maxCasesView_actionPerformed(e);
}});
// Event Exit
exit.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(ActionEvent e) {
exit_actionPerformed(e);
}});
//Event Close
this.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
this.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e){
exitWindow(e);
}});
//Event Close
disConnectionOzone.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(ActionEvent e) {
disConnectionOzone_actionPerformed(e);
}});
//Event Create new DBozone
openDb.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(ActionEvent e) {
openDb_actionPerformed(e);
}});
this.setJMenuBar(menuOp);
}
/** Order alphabetically of Attributes & Order of smaller to bigger
* @param Arraylist Lista, contain list non repeat values
* @param String typeAttribute, contain data type of list
* @exception Not Exception
*/
public ArrayList Ordenacion (ArrayList lista, String typeAttribute){
Collection c = new ArrayList();
ArrayList listaReturn = new ArrayList(); // List Value by type value
String key;
Iterator it = lista.iterator();
while (it.hasNext()){
key = (String) it.next();
if (typeAttribute.equals("String")){
listaReturn.add(key);
}else if (typeAttribute.equals("Integer")){
listaReturn.add(new Integer (key) );
}else if (typeAttribute.equals("Float")){
listaReturn.add(new Float (key));
}else{
listaReturn.add(key);
}
140
Estudio para la implementación de un sistema de razonamiento basado en casos
}
// Arranged values of Attributes by Type date
if (typeAttribute.equals("String")){
OrdenacionNombre ord = new OrdenacionNombre();
Collections.sort(listaReturn,ord);
}else if (typeAttribute.equals("Integer")){
OrdenacionInteger ordInt = new OrdenacionInteger();
Collections.sort(listaReturn,ordInt);
}else if (typeAttribute.equals("Float")){
OrdenacionFloat ordFloat = new OrdenacionFloat();
Collections.sort(listaReturn,ordFloat);
}else{
OrdenacionNombre ordBool = new OrdenacionNombre();
Collections.sort(listaReturn,ordBool);
}
return listaReturn;
}
/**Create list of non repeat values
* @param int index, contain index of Attribute in case
* @return retun list of not repeat values
* @exception Not Exceptions
*/
public ArrayList ItemsCombobox(int index) {
ArrayList listReturn = new ArrayList();
ArrayList listTemp = new ArrayList();
String attribute;
int attributeInt;
Iterator itCases = this.list.iterator();
while (itCases.hasNext()) { // While exist Cases
casesNew = (CasesImpl)itCases.next();
listTemp = casesNew.list();
attribute = (String)listTemp.get(index);
if (!listReturn.contains(attribute)){ // Value Attrinute is repeat at list?
listReturn.add(attribute);
}
}
return listReturn;
}
/**Add to combobox Not Numeric values
* @param JComboBox list, Combobox null
* @exception Not Exceptions
*/
protected void addNonNumericFilterOperators(JComboBox list) {
list.addItem("=");
list.addItem("!=");
list.setSelectedIndex(0);
}
/**Add to combobox Numeric values
* @param JComboBox list, Combobox null
* @exception Not Exceptions
*/
protected void addNumericFilterOperators(JComboBox list) {
list.addItem("=");
list.addItem("!=");
list.addItem(">");
list.addItem(">=");
list.addItem("<");
list.addItem("<=");
141
Estudio para la implementación de un sistema de razonamiento basado en casos
list.setSelectedIndex(0);
}
/**Add to combobox Bolean values
* @param JComboBox list, Combobox null
* @exception Not Exceptions
*/
protected void addBooleanFilterOperators(JComboBox list) {
list.addItem("=");
list.setSelectedIndex(0);
}
/**Action button Cancel in Similarity Search
* @param Not params
* @exception Not Exceptions
*/
void cancelButton_actionPerformed() {
this.getContentPane().setVisible(false);
this.getContentPane().removeAll();
ImageIcon imagen= new ImageIcon ("images/Dibujo.jpg"); // reload image
JLabel label = new JLabel(imagen);
this.getContentPane().add(label);
this.getContentPane().setVisible(true);
SearchSimil = false; // window Similarity is false
}
/**Load Items for Similarity motor Cbr Similarity Engine
* @param Not params
* @exception Not Exceptions
*/
protected void loadItems() {
try{
this.items = null;
ItemManager mainItemManager = new ItemManager( listMeta, list );
this.items = mainItemManager.getItems(); // return Items
DataSetStatistics stats = new DataSetStatistics( this.items );
// generate Stats of Items
} catch(Exception e){
JOptionPane.showMessageDialog( this, "Error in load items",
"Error", JOptionPane.ERROR_MESSAGE );
}
}
/**Action button Similarity Cases, find similar cases
* @param ActionEvent e, ActionEvent
* @exception Not Exceptions
*/
void submitButton_actionPerformed(ActionEvent e) {
TraitPanel panel;
String traitName, operator, value;
int traitDataType, weight;
boolean similarity = false;
Items matchedItems;
DataSetStatistics stats;
FilterEngine filterEngine;
SimilarItems similarItems = null;
SimilarityEngine similarityEngine = new SimilarityEngine();
FilterCriteria filterCriteria = new FilterCriteria();
SimilarityCriteria similarityCriteria = new SimilarityCriteria();
SimilarityWeights similarityWeights = new SimilarityWeights();
ResultsWindow resultsWindow;
Component component;
Component[] components;
142
Estudio para la implementación de un sistema de razonamiento basado en casos
try {
components = panelMain.getComponents(); // get all components in window
for (int i=0; i < components.length; i++) {
component = panelMain.getComponent(i);
if ( component.getClass() == TraitPanel.class ) {
panel = (TraitPanel) component;
// Similarity Criteria
if (panel.hasSimilarityCriteria()) { // is activate
// checkbox for similarCriteria
similarity = true;
traitName = panel.getTraitName(); // name
//Attribute
traitDataType = panel.getTraitDataType();
operator = "%";
switch (traitDataType) { // operators
//Selection Engine
case TYPE_INTEGER:
case TYPE_FLOAT:
operator = "~";
break;
case TYPE_STRING:
case TYPE_BOOLEAN:
operator = "%";
break;
}
value = panel.getPreferenceValue(); // prefer value of Attribute
weight = panel.getWeight();
// weigth value of Attribute
similarityCriteria.add( traitName, operator, value );
similarityWeights.add( traitName, weight );
}
// Operator Criteria
if (panel.hasFilterCriteria()) { // Require Checkbox
traitName = panel.getTraitName(); // name of attribute
operator = panel.getFilterOperator(); // operator
value = panel.getFilterValue(); // value attribute
filterCriteria.add( traitName, operator, value );
}
//--- hasFilterCriteria*/
}
}
}catch (Exception ex) {
JOptionPane.showMessageDialog( this, "Error Submit button Similarity Cases",
"Error", JOptionPane.ERROR_MESSAGE );
}
try {
// Cbr Motor
filterEngine = new FilterEngine();
matchedItems = filterEngine.filterItems( items, filterCriteria ); // return
//one object Items
// where eliminate items with filterCriteria
stats = new DataSetStatistics( items );
similarItems = similarityEngine.computeSimilarity(
matchedItems,
similarityCriteria,
similarityWeights,
143
Estudio para la implementación de un sistema de razonamiento basado en casos
stats );
// window results of similar cases
resultsWindow = new ResultsWindow(this, this.listMeta, similarItems,
items.getTraitDescriptors(), maxCases,similarity);
}catch (Exception excep) {
JOptionPane.showMessageDialog( this, "Error:"+ excep,
"Error", JOptionPane.ERROR_MESSAGE );
}
// Null Attributes for future consults
traitDataType = 0;
weight = 0;
traitName = null;
operator = null;
component = null;
components = null;
stats = null;
filterEngine = null;
similarItems = null;
filterCriteria = null; similarityEngine = null;
similarityWeights = null;
similarity = false;
value = null;
matchedItems = null; panel = null;
resultsWindow = null;
similarityCriteria = null;
}
/**Action button Help
* @param ActionEvent e, ActionEvent
* @exception Not Exceptions
*/
void help_actionPerformed(ActionEvent e) {
JOptionPane.showMessageDialog(this,
"CBR MODULE EXTRACTION\n" +
"*******************************\n" +
"PROGRAMMER:\n" +
"
Manuel Miguel Gimenez Arjona\n" +
"
manuelmiguel.gimenez@estudiants.urv.es\n\n" +
"DIRECTORS:\n" +
"
Ivan Lopez Arevalo / Aïda Valls Mateu\n" +
"
ivan.lopez@urv.net / aida.valls@urv.net\n\n" +
"LINKS:\n" +
"
[BANZAI Research Group]
http://www.etse.urv.es/recerca/banzai\n" +
"
[Dept. Enginyeria Informatica i Matematiques]
http://www.etse.urv.es/DEIM\n" +
"
[Universitat Rovira i Virgili]
http://www.urv.net\n" +
"
[Java]
http://www.java.sun.com\n" +
"
[Selection Engine]
http://selectionengine.sourceforge.net\n"
+
"
[Ozone Project]
http://www.ozone-db.org\n\n\n\n" +
"FOR TOPIC QUESTIONS:\n" +
"
manuelmiguel.gimenez@estudiants.urv.es\n" +
"
ivan.lopez@urv.net\n",
"ABOUT CBR..", JOptionPane.PLAIN_MESSAGE);
}
/**Action button New Find Similarity
* @param ActionEvent e, ActionEvent
* @exception Not Exceptions
*/
void newfind_actionPerformed(ActionEvent e) {
iniciateQuery();
}
/**Action Button MetaDAtaCase insert, Show Window Insert Metadata
* @param ActionEvent e, ActionEvent
* @exception Not Exceptions
*/
void metaDataOpCase_actionPerformed(ActionEvent e) {
WindowMetaDataCase metaDataCase = new WindowMetaDataCase (this, listMeta,
list, newFind, viewList, insertCase, editCase, deleteCase,
metaDataOpCase,maxCasesView);
144
Estudio para la implementación de un sistema de razonamiento basado en casos
}
/**Action button View List of cases, Show Window all cases
* @param ActionEvent e, ActionEvent
* @exception Not Exceptions
*/
void viewList_actionPerformed(ActionEvent e) {
WindowCaseView viewCase = new WindowCaseView (this, this.listMeta, this.list);
}
/**Action button View max cases and define number max
* @param ActionEvent e, ActionEvent
* @exception Not Exceptions
*/
void maxCasesView_actionPerformed(ActionEvent e) {
if (SearchSimil == true){ // if query window is activate
cancelButton_actionPerformed();
}
// new max show similar cases
String code = JOptionPane.showInputDialog(this,"Max Cases is " + maxCases +
" , put new max similar cases");
if (code != null) { // is null?
try{
int var = Integer.parseInt(code);
maxCases = var;
} catch (NumberFormatException e2) {
JOptionPane.showMessageDialog( this, "Error: Require
Integer", "Error", JOptionPane.ERROR_MESSAGE );
}
}
}
/**Action button Insert new Case
* @param ActionEvent e, ActionEvent
* @exception Not Exceptions
*/
void insertCase_actionPerformed(ActionEvent e) {
if (SearchSimil == true){ // if query window is activate
cancelButton_actionPerformed();
}
WindowCaseNew newCase = new WindowCaseNew(this, listMeta, casesAcces,
this.list, ozoneRepository);
}
/**Action button Disconnect Ozone
* @param ActionEvent e, ActionEvent
* @exception Not Exceptions
*/
void disConnectionOzone_actionPerformed(ActionEvent e) {
try {
ozoneRepository.saveDataBase(this, listMeta); // save metacases
ozoneRepository.close(); // close CaseBase conexion with aplication
newFind.setEnabled(false);
viewList.setEnabled(false);
maxCasesView.setEnabled(false);
insertCase.setEnabled(false);
editCase.setEnabled(false);
deleteCase.setEnabled(false);
metaDataOpCase.setEnabled(false);
145
Estudio para la implementación de un sistema de razonamiento basado en casos
disConnectionOzone.setEnabled(false);
openDb.setEnabled(true);
}catch (Exception excep) {
JOptionPane.showMessageDialog( this, "Error: Disconnect Ozone",
"Error", JOptionPane.ERROR_MESSAGE );
}
}
/**Action Button Edit case
* @param ActionEvent e, ActionEvent
* @exception Not Exceptions
*/
void editCase_actionPerformed(ActionEvent e) {
if (SearchSimil == true){ // if query window is activate
cancelButton_actionPerformed();
}
CasesImpl caseCode; // Case
// code reference of case
String code = JOptionPane.showInputDialog(this,"Code Reference");
if (code != null) {
if(casesAcces.containsKey(code)){ // this reference exist in hashTable
// of cases?
CasesImpl caseObtain = (CasesImpl)casesAcces.get(code); //
recuperate Case
//Show window edit
WindowCaseEdit newCase = new WindowCaseEdit(this, this.listMeta, //
casesAcces,
this.list,
code,
caseObtain,
ozoneRepository);
}else{
JOptionPane.showMessageDialog( this, "Error: Code Reference not exist",
"Error", JOptionPane.ERROR_MESSAGE );
}
}
}
/**Action button delete Case
* @param ActionEvent e, ActionEvent
* @exception Not Exceptions
*/
void deleteCase_actionPerformed(ActionEvent e) {
if (SearchSimil == true){ // if query window is activate
cancelButton_actionPerformed();
}
CasesImpl caseCode; // Case
// code reference of case
String code = JOptionPane.showInputDialog(this,"Code Reference");
if (code != null) {
if(casesAcces.containsKey(code)){ // this reference exist in
//hashTable of cases?
CasesImpl caseObtain = (CasesImpl)casesAcces.get(code); //
//recuperate Case
//Show window delete case
WindowCaseDelete newCase = new WindowCaseDelete(this, this.listMeta,
146
Estudio para la implementación de un sistema de razonamiento basado en casos
casesAcces,
this.list,
code,
caseObtain,
ozoneRepository);
}else{
JOptionPane.showMessageDialog( this, "Error: Code Reference not exist",
"Error", JOptionPane.ERROR_MESSAGE );
}
}
}
/**Action button open CaseBase
* @param ActionEvent e, ActionEvent
* @exception Not Exceptions
*/
void openDb_actionPerformed(ActionEvent e) {
try {
ozoneRepository = new RepositoryOzone(); // repository Ozone
ozoneRepository.open();
// conect aplication to Ozone
disConnectionOzone.setEnabled(true);
openDb.setEnabled(false);
//ozoneRepository.create(); // create in file.dat
list = ozoneRepository.getCases(this);
listMeta = ozoneRepository.getMeta(this);
if ( listMeta.size() != 0 ){ // if have metacases
if (list.size() != 0){ // if have cases
loadItems(); // Load items for selection engine
// load Cases in the estructures Hash & array list
WindowProgressBarReload progressBar = new WindowProgressBarReload(this,
casesAcces,list);
}
newFind.setEnabled(true);
viewList.setEnabled(true);
maxCasesView.setEnabled(true);
insertCase.setEnabled(true);
editCase.setEnabled(true);
deleteCase.setEnabled(true);
}else{
metaDataOpCase.setEnabled(true);
}
}catch (Exception excep) {
JOptionPane.showMessageDialog( this, "Error: open CaseBase",
"Error", JOptionPane.ERROR_MESSAGE );
}
}
/**Action button Exit Program
* @param ActionEvent e, ActionEvent
* @exception Not Exceptions
*/
void exit_actionPerformed(ActionEvent e) {
if (JOptionPane.showConfirmDialog(this,"Are you sure to Exit?",
"Exit Program",JOptionPane.YES_NO_OPTION)
==JOptionPane.YES_OPTION){
try {
147
Estudio para la implementación de un sistema de razonamiento basado en casos
ozoneRepository.saveDataBase(this, listMeta); // save
//metacases
ozoneRepository.close();
//
//ozone close conection
System.exit(0);
}catch (Exception excep) {
System.exit(0);
}
}
}
/**Action button Exit Program window
* @param ActionEvent e, ActionEvent
* @exception Not Exceptions
*/
void exitWindow(WindowEvent e){
if(JOptionPane.showConfirmDialog(this,"Are you sure to Exit?",
"Exit Program",JOptionPane.YES_NO_OPTION)
==JOptionPane.YES_OPTION){
try {
ozoneRepository.saveDataBase(this, listMeta); // save
//metacases
ozoneRepository.close();
//
//ozone close conection
System.exit(0);
}catch (Exception excep) {
System.exit(0);
}
}
}
//end
}
*******************************************************************************************
DataSetStatistics.java
*******************************************************************************************
/**
This class has been modified to comment the methods
modified by Manuel Miguel Gimenez Arjona
*/
package net.sourceforge.selectionengine;
import java.util.*;
/**
* This is a collection of TraitStatistics objects
* There is one TraitStatistics object per Trait
*
(the name is plural because each trait has multiple stats)
*
* DataSetStatistics builds the collection of TraitStatistics
*
and is responsible for converting everything to floating
*
points, which is what TraitStatistics wants
* Strings and booleans aren't really processed. Just set
*
the max and min to 1 and 0
*
* @author <small>baylor</small>
*
*/
public class DataSetStatistics {
//----------------------------------------------------------------------------// Attributes
//----------------------------------------------------------------------------HashMap dataSetStatistics;
//--- collection of TraitStatistics
148
Estudio para la implementación de un sistema de razonamiento basado en casos
//----------------------------------------------------------------------------// Constructors
//----------------------------------------------------------------------------public DataSetStatistics( Items items ) {
createCollection( items.getTraitDescriptors() );
buildStatistics( items );
} //--- constructor
//----------------------------------------------------------------------------// Methods
//----------------------------------------------------------------------------/** add TraitStatistics to hashmap
* @param TraitStatistics traitStatistics
* @exception Not Exceptions
*/
private void add( TraitStatistics traitStatistics ) {
String key = traitStatistics.getTraitName();
dataSetStatistics.put( key, traitStatistics );
} //--- add
/** build Statistics
* @param Items items, collection of item
* @exception Not Exceptions
*/
private void buildStatistics( Items items ) {
Iterator itemList = items.iterator();
while (itemList.hasNext()) {
Item item = (Item) itemList.next();
}
measureItemTraits( item );
} //--- hasNext
//--- buildStatistics
/** Create collection TraitStatistics
* @param TraitDescriptors descriptors
* @exception Not Exceptions
*/
private void createCollection( TraitDescriptors descriptors ) {
this.dataSetStatistics = new HashMap();
Iterator cursor = descriptors.iterator();
while (cursor.hasNext()) {
TraitDescriptor descriptor = (TraitDescriptor) cursor.next();
String traitName = descriptor.getName();
TraitStatistics traitStats = new TraitStatistics( traitName );
//--- We can pretty much skip any traits that aren't numeric
//--- We'll create a stats object but make it binary //--min=0, max=1, a value either matches exactly or it don't
if ( (descriptor.getDataType() !=
TraitDescriptor.TYPE_FLOAT ) &&
(descriptor.getDataType() !=
TraitDescriptor.TYPE_INTEGER) ) {
traitStats.setMinimumValue( 0 );
traitStats.setMaximumValue( 1 );
}
}
this.add( traitStats );
} //--- while hasNext
//--- createCollection
/** measureItemTraits
* @param Item item,item case
* @exception Not Exceptions
*/
private void measureItemTraits( Item item ) {
Iterator traitList = item.iterator();
while (traitList.hasNext()) {
Trait trait = (Trait) traitList.next();
String traitName = trait.getName();
int dataType = item.getTraitDataType( traitName );
//--- We're only going to measure stats for numbers
149
Estudio para la implementación de un sistema de razonamiento basado en casos
//--- When we initialized the data set statistics collection,
//--we set the stats for all strings and booleans to
//--min=0 max=1, which is the only values we'd ever
//--recognize, so we can just ignore strings and bools here
if ( (dataType == TraitDescriptor.TYPE_FLOAT ) ||
(dataType == TraitDescriptor.TYPE_INTEGER) ) {
}
TraitStatistics traitStats = this.get( traitName );
float value = trait.getValue().toFloat();
traitStats.addExample( value );
}
} //--- hasNext
//--- measureItemTraits
//----------------------------------------------------------------------------// Accessors
//----------------------------------------------------------------------------/** get traitStatistics
* @param String traitName, name of Attribute
* @return TraitStatistics
* @exception Not Exceptions
*/
public TraitStatistics get( String traitName ) {
return (TraitStatistics) dataSetStatistics.get( traitName );
} //--- get
}
//--- DataSetStatistics
*******************************************************************************************
ExampleFileFilter.java
*******************************************************************************************
/*
* @(#)ExampleFileFilter.java
1.8 98/08/26
*
* Copyright 1998 by Sun Microsystems, Inc.,
* 901 San Antonio Road, Palo Alto, California, 94303, U.S.A.
* All rights reserved.
*
* This software is the confidential and proprietary information
* of Sun Microsystems, Inc. ("Confidential Information"). You
* shall not disclose such Confidential Information and shall use
* it only in accordance with the terms of the license agreement
* you entered into with Sun.
*/
package cbr;
import java.io.File;
import java.util.Hashtable;
import java.util.Enumeration;
import javax.swing.*;
import javax.swing.filechooser.*;
/**
* A convenience implementation of FileFilter that filters out
* all files except for those type extensions that it knows about.
*
* Extensions are of the type ".foo", which is typically found on
* Windows and Unix boxes, but not on Macinthosh. Case is ignored.
*
* Example - create a new filter that filerts out all files
* but gif and jpg image files:
*
*
JFileChooser chooser = new JFileChooser();
*
ExampleFileFilter filter = new ExampleFileFilter(
*
new String{"gif", "jpg"}, "JPEG & GIF Images")
*
chooser.addChoosableFileFilter(filter);
*
chooser.showOpenDialog(this);
*
* @version 1.8 08/26/98
* @author Jeff Dinkins
*/
150
Estudio para la implementación de un sistema de razonamiento basado en casos
public class ExampleFileFilter extends FileFilter {
private static String TYPE_UNKNOWN = "Type Unknown";
private static String HIDDEN_FILE = "Hidden File";
private
private
private
private
Hashtable filters = null;
String description = null;
String fullDescription = null;
boolean useExtensionsInDescription = true;
/**
* Creates a file filter. If no filters are added, then all
* files are accepted.
*
* @see #addExtension
*/
public ExampleFileFilter() {
this.filters = new Hashtable();
}
/**
* Creates a file filter that accepts files with the given extension.
* Example: new ExampleFileFilter("jpg");
*
* @see #addExtension
*/
public ExampleFileFilter(String extension) {
this(extension,null);
}
/**
* Creates a file filter that accepts the given file type.
* Example: new ExampleFileFilter("jpg", "JPEG Image Images");
*
* Note that the "." before the extension is not needed. If
* provided, it will be ignored.
*
* @see #addExtension
*/
public ExampleFileFilter(String extension, String description) {
this();
if(extension!=null) addExtension(extension);
if(description!=null) setDescription(description);
}
/**
* Creates a file filter from the given string array.
* Example: new ExampleFileFilter(String {"gif", "jpg"});
*
* Note that the "." before the extension is not needed adn
* will be ignored.
*
* @see #addExtension
*/
public ExampleFileFilter(String[] filters) {
this(filters, null);
}
/**
* Creates a file filter from the given string array and description.
* Example: new ExampleFileFilter(String {"gif", "jpg"}, "Gif and JPG Images");
*
* Note that the "." before the extension is not needed and will be ignored.
*
* @see #addExtension
*/
public ExampleFileFilter(String[] filters, String description) {
this();
for (int i = 0; i < filters.length; i++) {
// add filters one by one
addExtension(filters[i]);
}
151
Estudio para la implementación de un sistema de razonamiento basado en casos
if(description!=null) setDescription(description);
}
/**
* Return true if this file should be shown in the directory pane,
* false if it shouldn't.
*
* Files that begin with "." are ignored.
*
* @see #getExtension
* @see FileFilter#accept
*/
public boolean accept(File f) {
if(f != null) {
if(f.isDirectory()) {
return true;
}
String extension = getExtension(f);
if(extension != null && filters.get(getExtension(f)) != null) {
return true;
};
}
return false;
}
/**
* Return the extension portion of the file's name .
*
* @see #getExtension
* @see FileFilter#accept
*/
public String getExtension(File f) {
if(f != null) {
String filename = f.getName();
int i = filename.lastIndexOf('.');
if(i>0 && i<filename.length()-1) {
return filename.substring(i+1).toLowerCase();
};
}
return null;
}
/**
* Adds a filetype "dot" extension to filter against.
*
* For example: the following code will create a filter that filters
* out all files except those that end in ".jpg" and ".tif":
*
*
ExampleFileFilter filter = new ExampleFileFilter();
*
filter.addExtension("jpg");
*
filter.addExtension("tif");
*
* Note that the "." before the extension is not needed and will be ignored.
*/
public void addExtension(String extension) {
if(filters == null) {
filters = new Hashtable(5);
}
filters.put(extension.toLowerCase(), this);
fullDescription = null;
}
/**
* Returns the human readable description of this filter. For
* example: "JPEG and GIF Image Files (*.jpg, *.gif)"
*
* @see #setDescription
* @see #setExtensionListInDescription
* @see #isExtensionListInDescription
* @see FileFilter#getDescription
*/
public String getDescription() {
if(fullDescription == null) {
152
Estudio para la implementación de un sistema de razonamiento basado en casos
if(description == null || isExtensionListInDescription()) {
fullDescription = description==null ? "(" : description + " (";
// build the description from the extension list
Enumeration extensions = filters.keys();
if(extensions != null) {
fullDescription += "." + (String) extensions.nextElement();
while (extensions.hasMoreElements()) {
fullDescription += ", " + (String) extensions.nextElement();
}
}
fullDescription += ")";
} else {
fullDescription = description;
}
}
return fullDescription;
}
/**
* Sets the human readable description of this filter. For
* example: filter.setDescription("Gif and JPG Images");
*
* @see #setDescription
* @see #setExtensionListInDescription
* @see #isExtensionListInDescription
*/
public void setDescription(String description) {
this.description = description;
fullDescription = null;
}
/**
* Determines whether the extension list (.jpg, .gif, etc) should
* show up in the human readable description.
*
* Only relevent if a description was provided in the constructor
* or using setDescription();
*
* @see #getDescription
* @see #setDescription
* @see #isExtensionListInDescription
*/
public void setExtensionListInDescription(boolean b) {
useExtensionsInDescription = b;
fullDescription = null;
}
/**
* Returns whether the extension list (.jpg, .gif, etc) should
* show up in the human readable description.
*
* Only relevent if a description was provided in the constructor
* or using setDescription();
*
* @see #getDescription
* @see #setDescription
* @see #setExtensionListInDescription
*/
public boolean isExtensionListInDescription() {
return useExtensionsInDescription;
}
}
*******************************************************************************************
FilterCriteria.java
*******************************************************************************************
/**
153
Estudio para la implementación de un sistema de razonamiento basado en casos
This class create one collection of Filtercriterion Objects,
Filtercriterion Objects indicates if Item violates criterions usrs
This class has been modified to comment the methods
modified by Manuel Miguel Gimenez Arjona
*/
package net.sourceforge.selectionengine;
import java.util.*;
/**
*
* @author <small>baylor</small>
*
*/
public class FilterCriteria {
//--- Here's where we hold all our data
private ArrayList data = new ArrayList();
/** Add collection of filterCriterion
* @param String field, name of attribute
* @param String operator, operator criterion
* @param String value, value of attribute
* @exception Not Exceptions
*/
public void add( String field, String operator, String value ) {
FilterCriterion criterion = new FilterCriterion( field, operator, value );
}
data.add( criterion );
//--- add
/**
* This has to return Object because that's how
* it's defined in the super class
*/
public Object clone( ) {
FilterCriteria newFilterCriteria = new FilterCriteria();
newFilterCriteria.setValues( data );
}
return (Object) newFilterCriteria;
//--- clone
/** Iterator
* @param Not params
* @return Iterator
* @exception Not Exceptions
*/
public Iterator iterator() {
return data.iterator();
}
/** Set values
* @param ArrayList newValues, arraylist new
* @exception Not Exceptions
*/
private void setValues( ArrayList newValues ) {
data = (ArrayList) newValues.clone();
}
/** get int Size
* @param Not params
* @return int size of collection
* @exception Not Exceptions
*/
public int size() {
return data.size();
}
}
//--- FilterCriteria
154
Estudio para la implementación de un sistema de razonamiento basado en casos
*******************************************************************************************
FilterCriterion.java
*******************************************************************************************
/**
This class indicate if criterion users are violated by items
This class has been modified to comment the methods
modified by Manuel Miguel Gimenez Arjona
*/
package net.sourceforge.selectionengine;
/**
*
* @author <small>baylor</small>
*
*/
public class FilterCriterion
{
//----------------------------------------------------------------------------// Public constants
//----------------------------------------------------------------------------public static final int OPERATOR_UNKNOWN
= 0;
public static final int OPERATOR_EQUALS
= 1;
public static final int OPERATOR_NOT_EQUAL
= 2;
public static final int OPERATOR_GREATER_THAN
= 3;
public static final int OPERATOR_GREATER_THAN_OR_EQUAL = 4;
public static final int OPERATOR_LESS_THAN
= 5;
public static final int OPERATOR_LESS_THAN_OR_EQUAL
= 6;
//----------------------------------------------------------------------------// Attributes
//----------------------------------------------------------------------------protected String fieldName;
protected int operator;
protected TraitValue value;
//----------------------------------------------------------------------------// Constructors
//----------------------------------------------------------------------------protected FilterCriterion( String fieldName, String operator, String value ) {
this.fieldName = fieldName;
this.operator = stringToOperator( operator );
this.value = new TraitValue( value );
} //--- constructor
//----------------------------------------------------------------------------// Methods
//----------------------------------------------------------------------------/** Return String Attribute
* @param not params
* @return String fieldName, name Attribute
* @exceptions Not Exceptions
*/
public String getFieldName() {
return fieldName;
}
/** Return integer Operator
* @param not params
* @return integer Operator
* @exceptions Not Exceptions
*/
public int getOperator() {
return operator;
}
/** Return String Opertor
* @param not params
* @return String Operator
* @exceptions Not Exceptions
*/
public String getOperatorAsString() {
155
Estudio para la implementación de un sistema de razonamiento basado en casos
return operatorToString( operator );
}
/** Return Value
* @param not params
* @return traitvalue value
* @exceptions Not Exceptions
*/
public TraitValue getValue() {
return value;
}
/** Return if Item violates criterion
* @param Item item, item of database
* @return boolean if violates
* @exceptions Not Exceptions
*/
public boolean itemViolates( Item item ) {
boolean violationFound = true;
int type = item.getTraitDataType( this.getFieldName() );
int operator = this.getOperator();
TraitValue itemValue = item.getTraitValue( this.getFieldName() );
//--- Ugly messy code
//--- Switch statements aren't great, nested ones are a sure sign
//--that someone (like me) didn't think this through very well
//--- Better fix this once i get this out of the quick and dirty
switch( operator ) {
case OPERATOR_EQUALS:
switch( type ) {
case TraitDescriptor.TYPE_BOOLEAN:
violationFound = (! (itemValue.toBoolean() == this.value.toBoolean()) );
break;
case TraitDescriptor.TYPE_FLOAT:
violationFound = (! (itemValue.toFloat() == this.value.toFloat()) );
break;
case TraitDescriptor.TYPE_INTEGER:
violationFound = (! (itemValue.toInteger() == this.value.toInteger()) );
break;
case TraitDescriptor.TYPE_STRING:
violationFound = (! (this.value.toString().equals(itemValue.toString())) );
break;
}
break;
case OPERATOR_NOT_EQUAL:
switch( type ) {
case TraitDescriptor.TYPE_BOOLEAN:
violationFound = (! (itemValue.toBoolean() != this.value.toBoolean()) );
break;
case TraitDescriptor.TYPE_FLOAT:
violationFound = (! (itemValue.toFloat() != this.value.toFloat()) );
break;
case TraitDescriptor.TYPE_INTEGER:
violationFound = (! (itemValue.toInteger() != this.value.toInteger()) );
break;
case TraitDescriptor.TYPE_STRING:
violationFound = (this.value.toString().equals(itemValue.toString()));
break;
}
break;
case OPERATOR_GREATER_THAN:
switch( type ) {
case TraitDescriptor.TYPE_FLOAT:
violationFound = (! (itemValue.toFloat() > this.value.toFloat()) );
break;
case TraitDescriptor.TYPE_INTEGER:
violationFound = (! (itemValue.toInteger() > this.value.toInteger()) );
break;
}
break;
case OPERATOR_GREATER_THAN_OR_EQUAL:
switch( type ) {
156
Estudio para la implementación de un sistema de razonamiento basado en casos
case TraitDescriptor.TYPE_FLOAT:
violationFound = (! (itemValue.toFloat() >= this.value.toFloat()) );
break;
case TraitDescriptor.TYPE_INTEGER:
violationFound = (! (itemValue.toInteger() >= this.value.toInteger()) );
break;
}
break;
case OPERATOR_LESS_THAN:
switch( type ) {
case TraitDescriptor.TYPE_FLOAT:
violationFound = (! (itemValue.toFloat() < this.value.toFloat()) );
break;
case TraitDescriptor.TYPE_INTEGER:
violationFound = (! (itemValue.toInteger() < this.value.toInteger()) );
break;
}
break;
case OPERATOR_LESS_THAN_OR_EQUAL:
switch( type ) {
case TraitDescriptor.TYPE_FLOAT:
violationFound = (! (itemValue.toFloat() <= this.value.toFloat()) );
break;
case TraitDescriptor.TYPE_INTEGER:
violationFound = (! (itemValue.toInteger() <= this.value.toInteger()) );
break;
}
break;
} //--- switch( operator )
}
return violationFound;
//--- itemViolates
/** Return String Opertor
* @param int operator
* @return String Operator
* @exceptions Not Exceptions
*/
private String operatorToString( int operator ) {
String stringValue = null;
if (operator == OPERATOR_EQUALS) {
stringValue = "=";
} else
if (operator == OPERATOR_NOT_EQUAL) {
stringValue = "!=";
} else
if (operator == OPERATOR_GREATER_THAN) {
stringValue = ">";
} else
if (operator == OPERATOR_GREATER_THAN_OR_EQUAL) {
stringValue = ">=";
} else
if (operator == OPERATOR_LESS_THAN) {
stringValue = "<";
} else
if (operator == OPERATOR_LESS_THAN_OR_EQUAL) {
stringValue = "<=";
} //--- figure out the operator
}
return stringValue;
//--- operatorToString
/** Return intOpertor
* @param String operator
* @return int Operator
* @exceptions Not Exceptions
*/
private int stringToOperator( String operator ) {
int numericValue = OPERATOR_UNKNOWN;
if (operator.equals( "=" )) {
numericValue = OPERATOR_EQUALS;
} else
157
Estudio para la implementación de un sistema de razonamiento basado en casos
if (operator.equals( "!=" )) {
numericValue = OPERATOR_NOT_EQUAL;
} else
if (operator.equals( ">" )) {
numericValue = OPERATOR_GREATER_THAN;
} else
if (operator.equals( ">=" )) {
numericValue = OPERATOR_GREATER_THAN_OR_EQUAL;
} else
if (operator.equals( "<" )) {
numericValue = OPERATOR_LESS_THAN;
} else
if (operator.equals( "<=" )) {
numericValue = OPERATOR_LESS_THAN_OR_EQUAL;
} //--- figure out the operator
}
}
return numericValue;
//--- stringToDataType
//--- FilterCriterion
*******************************************************************************************
FilterEngine.java
*******************************************************************************************
/**
This class filter Items that violates criterion require by user,
create the collection that only contain there items
that not violate criterion.
This class has been modified to comment the methods
modified by Manuel Miguel Gimenez Arjona
*/
package net.sourceforge.selectionengine;
import java.util.*;
/**
*
* @author <small>baylor</small>
*
*/
public class FilterEngine {
/** Return Items filtered
* @param Items items, Tems for filter
* @param FilterCriteria filterCriteria, criterions user
* @return Items filteredItems, Items filtered
* @exceptions Not Exceptions
*/
public Items filterItems( Items items, FilterCriteria filterCriteria ) {
Items filteredItems = new Items( items.getTraitDescriptors() );
Item item;
Iterator itemsCursor;
boolean var;
//--- Go through each item and see if violates any of our rules
itemsCursor = items.iterator();
while (itemsCursor.hasNext()) {
item = (Item) itemsCursor.next();
//--- Does this item violate any of our filter criteria?
var = violatesCriteria( item, filterCriteria );
//System.out.println (var);
if (!(var)) {
//--- It didn't violate any criteria so let's keep this one
//System.out.println ("adiciona a filteredItems ");
filteredItems.add( item );
}
} //--- while hasNext
return filteredItems;
158
Estudio para la implementación de un sistema de razonamiento basado en casos
}
//--- filterItems
/** Return if violated criteria user
* @param Item item, Tems for filter
* @param FilterCriteria filterCriteria, criterions user
* @return boolean, if true or false if violates
* @exceptions Not Exceptions
*/
private boolean violatesCriteria( Item item, FilterCriteria criteria ) {
Iterator listOfRules = criteria.iterator();
FilterCriterion criterion;
//--- Look through each filter rule we have to see if any of them
//--disqualify this particular item
while (listOfRules.hasNext()) {
criterion = (FilterCriterion) listOfRules.next();
if (criterion.itemViolates( item )) {
return true;
}
} //--- hasNext
//--- We won't get this far in the method unless none of the criteria
//--were matched
return false;
} //--- violatesCriteria
}
//--- FilterEngine
*******************************************************************************************
GetInfo.java
*******************************************************************************************
/**
Class GetInfo Read Metadata And Cases Of File.dat
Programmer: Manuel Miguel Gimenez Arjona
Proyect:CBR Extraccion Module
Directors Proyect: Ivan Lopez Arevalo / Aïda Valls Mateu
University: Universitat Rovira i Virgili
Date: 2.08.2005
*/
package cbr;
import java.io.*;
import java.util.*;
import org.ozoneDB.*;
public class GetInfo {
ArrayList list = new ArrayList();
ArrayList listMeta = new ArrayList ();
ArrayList casesTemp;
/**GetInfo
* @param String File, name of File
* @param EsternalDataBase db, Db of Ozone
* @exception Not Exceptions
*/
public GetInfo(String file,ExternalDatabase db){
extract_information(file,db);
}
/**Obtain information and generate cases in db
* @param String File, name of File
* @param EsternalDataBase db, Db of Ozone
* @exception Not Exceptions
*/
public void extract_information(String file, ExternalDatabase db){
159
Estudio para la implementación de un sistema de razonamiento basado en casos
//var
int charIn;
String fixsubstring;
String fixstring = new String("");
StringTokenizer tokens;
int entryNumber = 0;
int entryNumberCases = 0;
int entryNumberMetaInfo = 0;
String tempAttribute;
String tempNotInclude;
StringBuffer temp;
MetaInfoImpl metaInf;
CasesImpl cases;
try{
FileInputStream filesourcedesign = new FileInputStream(file);
while ((charIn=filesourcedesign.read())!=-1) fixstring +=((char)charIn);
filesourcedesign.close();
tokens = new StringTokenizer(fixstring);
while (tokens.hasMoreTokens()) { //while exist tokens
fixsubstring = new String(tokens.nextToken());
if (fixsubstring.equals("Metadata")){
// metadata Information
fixsubstring = new String(tokens.nextToken());
while (!fixsubstring.equals("@")) {
// end of metadata
tempAttribute = fixsubstring;
tempNotInclude = tempAttribute.substring(0,4);
metaInf = new MetaInfoImpl();
if (tempNotInclude.equals("Not:")){
temp = new StringBuffer(tempAttribute);
tempAttribute = String.valueOf(temp.delete(0,4));
metaInf.setName_attribute(tempAttribute);
metaInf.setIncluded(false);
}else{ // Visible Attribute
metaInf.setName_attribute(tempAttribute);
}
fixsubstring = new String(tokens.nextToken());
metaInf.setTypeName_attribute(fixsubstring);
listMeta.add(entryNumberMetaInfo,metaInf);
entryNumberMetaInfo++;
fixsubstring = new String(tokens.nextToken());
}
} else { // cases
casesTemp = new ArrayList();
System.out.println(fixsubstring);
while (!fixsubstring.equals("@")) { // end of one case
casesTemp.add(entryNumber,fixsubstring);
fixsubstring = new String(tokens.nextToken());
entryNumber++;
}
entryNumber = 0;
cases = new CasesImpl();
cases.setList(casesTemp);
list.add(entryNumberCases,cases);
160
Estudio para la implementación de un sistema de razonamiento basado en casos
entryNumberCases++;
}
}
}catch(IOException e) {
System.out.println("File-Open Error: "+file);
}
try{
// COLLECTION Cases
CasesGroup casesGroup = (CasesGroup)(db.createObject(CasesGroupImpl.class.getName(),
0,"Collection"));
Iterator itCases = this.list.iterator();
while (itCases.hasNext()) {
CasesImpl casesNew = (CasesImpl) itCases.next();
casesGroup.addCases(casesNew);
}
// METADATOS
MetaInfoGroup metaInfoGroup =
(MetaInfoGroup)(db.createObject(MetaInfoGroupImpl.class.getName(), 0,"MetaCollection"));
Iterator itMeta = this.listMeta.iterator();
while (itMeta.hasNext()) {
MetaInfoImpl metaInfoNew = (MetaInfoImpl)itMeta.next();
metaInfoGroup.addMeta(metaInfoNew);
}
} catch(Exception e){
System.out.println("Error at" + e);
}
}
} //end
*******************************************************************************************
Item.java
*******************************************************************************************
/**
This class is the reprensentation of a one case of database cases
Item is asociate with yours traitDescriptors and one Object Traits. Traits
is a collection of objects trait, each object trait is a Attribute and your
value
This class has been modified to comment the methods
modified by Manuel Miguel Gimenez Arjona
*/
package net.sourceforge.selectionengine;
import cbr.*;
import java.util.*;
/**
*
* @author <small>baylor</small>
*
161
Estudio para la implementación de un sistema de razonamiento basado en casos
*/
public class Item {
//----------------------------------------------------------------------------// Attributes
//----------------------------------------------------------------------------Traits traits = new Traits();
TraitDescriptors traitDescriptors;
//----------------------------------------------------------------------------// Constructors
//----------------------------------------------------------------------------protected Item( TraitDescriptors traitDescriptors ) {
this.traitDescriptors = traitDescriptors;
}
//----------------------------------------------------------------------------// Methods
//----------------------------------------------------------------------------/**
return datatype of Attribute
* @param String traitName, name of attribute
* @return int datatype
* @exception Not Exceptions
*/
public int getTraitDataType( String traitName ) {
TraitDescriptor traitDescriptor = traitDescriptors.get( traitName );
}
return traitDescriptor.getDataType();
//--- getTraitValue
/**
return Value of Attribute
* @param String traitName, name of attribute
* @return traitValue
* @exception Not Exceptions
*/
public TraitValue getTraitValue( String traitName ) {
Trait trait = traits.get( traitName );
}
return trait.getValue();
//--- getTraitValue
/**
Iterator
* @param not params
* @return iterator
* @exception Not Exceptions
*/
public Iterator iterator() {
return traits.iterator();
}
/**
* Assumption: good data is passed in.
* This method does not currently do any error checking like
*
making sure the number of fields matches the number of
*
| delimited items in the data
* Hey, it's prototype code, what do you expect?
*/
protected void loadFromDelimitedCase(TraitDescriptors traitDescriptors,
ArrayList caseItem ) {
try {
traits.loadFromDelimitedCase( traitDescriptors, caseItem );
}
}
} //--- try
catch (Exception e) {
e.printStackTrace();
} //--- catch
//--- loadFromDelimitedString
//--- Item
162
Estudio para la implementación de un sistema de razonamiento basado en casos
*******************************************************************************************
ItemManager.java
*******************************************************************************************
/**
This class load the items cases with your traitDescritors, Finally of the class
is create a collection of all items from data base
This class has been modified to comment the methods
modified by Manuel Miguel Gimenez Arjona
*/
package net.sourceforge.selectionengine;
import java.io.*;
import java.util.*;
import cbr.*;
/**
*
* @author <small>baylor</small>
*
*/
public class ItemManager {
//--- Static for performance. i don't want to have each instance
//--of this load its own data from the data source
private TraitDescriptors traitDescriptors = new TraitDescriptors();
private Items items = new Items( traitDescriptors );
CasesImpl casesNew;
/** Add Cases to collection Items
* @param ArrayList listMeta, list metacases
* @param ArrayList listCases, list cases
* @exceptions Not Exceptions
*/
public ItemManager( ArrayList listMeta, ArrayList listCases) throws Exception {
//added by Manuel Miguel Gimenez Arjona
traitDescriptors.loadTraitDescriptorOfCase(listMeta); //load traitdescriptors
Iterator itCases = listCases.iterator();
int i= 0;
while (itCases.hasNext()) {
casesNew = (CasesImpl)itCases.next();
items.add( getTraitDescriptors(), casesNew.list() );
i++;
}
}
/** getItems
* @param Not params
* @return Items
* @exceptions Not Exceptions
*/
public Items getItems() {
return items;
}
/** get TraitDescriptors
* @param Not params
* @return TraitDescriptors
* @exceptions Not Exceptions
*/
public TraitDescriptors getTraitDescriptors() {
return traitDescriptors;
}
}
*******************************************************************************************
Items.java
*******************************************************************************************
/**
This class Ítems is the object that contains one collection of objects Item.
163
Estudio para la implementación de un sistema de razonamiento basado en casos
Item is a one case of Data cases.
This collection of Items are cases of case base reasoning
This class has been modified to comment the methods
modified by Manuel Miguel Gimenez Arjona
*/
package net.sourceforge.selectionengine;
import cbr.*;
import java.util.*;
/**
*
* @author <small>baylor</small>
*
*/
public class Items {
//----------------------------------------------------------------------------// Attributes
//----------------------------------------------------------------------------ArrayList data = new ArrayList();
TraitDescriptors traitDescriptors;
//----------------------------------------------------------------------------// Constructors
//----------------------------------------------------------------------------/**
* This is the only constructor and it requires TraitDescriptors
* Technically, Items doesn't need to know anything about TraitDescriptors,
*
but a lot of the people who use Items (actually, Item) do.
*
They could create their own copy, but that would be slow, what with
*
all the loading and what not. Ditto for storing it with each Item.
*
So storing TraitDescriptors here is just a minor performance tuning thingy
*/
protected Items( TraitDescriptors traitDescriptors ) {
this.traitDescriptors = traitDescriptors;
} //--- constructor
//----------------------------------------------------------------------------// Methods
//----------------------------------------------------------------------------protected void add( Item item ) {
data.add( item );
} //--- add
/**
This method create Item and asociate your traitDescriptors and arraylist of collection
attribute - value. Finally insert at collection Items
* @param TraitDescriptors traitDescriptors, collection description Attributes
* @param ArrayList caseItem, caseItem
* @exception Not Exceptions
*/
protected void add( TraitDescriptors traitDescriptors, ArrayList caseItem ) {
Item item = new Item( traitDescriptors );
item.loadFromDelimitedCase( traitDescriptors, caseItem );
this.add( item );
}
//--- add
/**
clone Items and return
* @param not params
* @return Object
* @exception Not Exceptions
*/
public Object clone( ) {
Items newItems = new Items( traitDescriptors );
newItems.setValues( data );
}
return (Object) newItems;
//--- clone
164
Estudio para la implementación de un sistema de razonamiento basado en casos
/**
return traitDescriptors, Attributes of case
* @param not params
* @return traitDescriptors
* @exception Not Exceptions
*/
public TraitDescriptors getTraitDescriptors() {
return traitDescriptors;
}
/**
Iterator for collection
* @param not params
* @return iterator
* @exception Not Exceptions
*/
public Iterator iterator() {
return data.iterator();
}
/**
Asociate new collection
* @param ArrayList newValues, collection of Items
* @exception Not Exceptions
*/
private void setValues( ArrayList newValues ) {
data = (ArrayList) newValues.clone();
}
/**
* Number of items in the collection
* @param not params
* @return int size, size of collection
* @exception Not Exceptions
*/
}
public int size() {
return data.size();
}
//--- Ítems
*******************************************************************************************
MetaInfo.java
*******************************************************************************************
/**
Interface used by ozone casebase for define the methods for Metainfo objects,
Programmer: Manuel Miguel Gimenez Arjona
Proyect:CBR Extraccion Module
Directors: Ivan Lopez Arevalo / Aïda Valls Mateu
Departament de Enginyeria Informatica i Matematiques
Universitat Rovira i Virgili
Date: 2.08.2005
*/
package cbr;
import org.ozoneDB.OzoneRemote;
import java.util.*;
public interface MetaInfo extends OzoneRemote {
public String name_attribute();
public void setName_attribute( String name ); /*update*/
public String typeName_attribute();
165
Estudio para la implementación de un sistema de razonamiento basado en casos
public void setTypeName_attribute( String name ); /*update*/
public boolean included();
public void setIncluded( boolean included ); /*update*/
}
*******************************************************************************************
MetaInfoGroup.java
*******************************************************************************************
**
Interface used by ozone casebase for define the methods for MetainfoGroup objects,
Programmer: Manuel Miguel Gimenez Arjona
Proyect:CBR Extraccion Module
Directors: Ivan Lopez Arevalo / Aïda Valls Mateu
Departament de Enginyeria Informatica i Matematiques
Universitat Rovira i Virgili
Date: 2.08.2005
*/
package cbr;
import org.ozoneDB.OzoneRemote;
import java.util.*;
public interface MetaInfoGroup extends OzoneRemote {
public void addMeta (MetaInfoImpl meta) throws Exception; /*update*/
public ArrayList getMeta();
public MetaInfoImpl getMeta( int key );
public MetaInfoImpl removeMeta( int key );
}
*******************************************************************************************
MetaInfoGroupImpl.java
*******************************************************************************************
/**
Class MetaInfoGroupImpl, Class contain metadata information.
This objecto contain one collection of object MetaInfoImpl
Programmer: Manuel Miguel Gimenez Arjona
Proyect:CBR Extraccion Module
Directors Proyect: Ivan Lopez Arevalo / Aïda Valls Mateu
University: Universitat Rovira i Virgili
Date: 2.08.2005
*/
package cbr;
import org.ozoneDB.OzoneObject;
import java.util.*;
public class MetaInfoGroupImpl extends OzoneObject implements MetaInfoGroup {
final static long serialVersionUID = 1L;
private ArrayList meta;
private int numMetaInfo = 0;
166
Estudio para la implementación de un sistema de razonamiento basado en casos
/**MetaINfoGroupImpl
* @param Not Param
* @exception Not Exceptions
*/
public MetaInfoGroupImpl() {
meta = new ArrayList();
}
/**Add metacase at list of MetaCases collection
* @param MetaInfoImpl meta, metacase for add
* @exception Exception Error at metaInfoGroupImpl
*/
public void addMeta(MetaInfoImpl meta) throws Exception {
try{
this.meta.add( numMetaInfo, meta );// index meta Info
numMetaInfo = numMetaInfo + 1;
} catch(Exception e){
System.out.println("Error at metaInfoGroupImpl::addMeta() "+e);
}
}
/**Add metacase at list of MetaCases collection
* @param Not Params
* @return ArrayList meta, list with metaCases
* @exception Not Exception
*/
public ArrayList getMeta() {
return this.meta;
}
/**Get one metaCase of ArrayList
* @param int key, integer position of metacase
* @return MetaInfoImpl
* @exception Not Exception
*/
public MetaInfoImpl getMeta( int key ) {
return (MetaInfoImpl)this.meta.get( key );
}
/**Remove metacase of list
* @param int key, integer position of metacase
* @return MetaInfoImpl
* @exception Not Exception
*/
public MetaInfoImpl removeMeta( int key ) {
return (MetaInfoImpl)this.meta.remove( key );
}
}
*******************************************************************************************
MetaInfoImpl.java
*******************************************************************************************
**
Class save one Attribut, your datatype and if is visible or not.
167
Estudio para la implementación de un sistema de razonamiento basado en casos
Programmer: Manuel Miguel Gimenez Arjona
Proyect:CBR Extraccion Module
Directors Proyect: Ivan Lopez Arevalo / Aïda Valls Mateu
University: Universitat Rovira i Virgili
Date: 2.08.2005
*/
package cbr;
import org.ozoneDB.OzoneObject;
import java.util.*;
import java.io.*;
public class MetaInfoImpl extends OzoneObject implements MetaInfo {
final static long serialVersionUID = 1L;
private String name_attribute;
private String typeName_attribute;
private boolean included = true;
/**MetaInfoImpl
* @param Not Params
* @exception Not Exception
*/
public MetaInfoImpl() {
}
/**Return name of attribute MetaCase
* @param Not Params
* @return String name_attribute, name of Attribute
* @exception Not Exception
*/
public String name_attribute() {
return name_attribute;
}
/**Set name of Attribute
* @param String name, name of attribute
* @exception Not Exception
*/
public void setName_attribute( String name ) {
this.name_attribute = name;
}
/**Return name of attribute MetaCase
* @param Not Params
* @return String typeName_attribute, name of Attribute
* @exception Not Exception
*/
public String typeName_attribute() {
return typeName_attribute;
}
/**Set Type of Attribute
* @param String name, Type Attibute (Integer, String, boolean, float)
* @exception Not Exception
*/
public void setTypeName_attribute( String name ) {
this.typeName_attribute = name;
}
/**Return included, if is visible or not
* @param Not param
* @return Boolean included, indicates if is visible or not
* @exception Not Exception
168
Estudio para la implementación de un sistema de razonamiento basado en casos
*/
public boolean included(){
return included;
}
/**Set included
* @param Boolean included, true or false
* @exception Not Exception
*/
public void setIncluded( boolean included ) {
this.included = included;
}
}
*******************************************************************************************
OrdenacionFloat.java
*******************************************************************************************
/**
Class OrdenacionFloat
Programmer: Manuel Miguel Gimenez Arjona
Proyect:CBR Extraccion Module
Directors: Ivan Lopez Arevalo / Aïda Valls Mateu
Departament de Enginyeria Informatica i Matematiques
Universitat Rovira i Virgili
Date: 2.08.2005
*/
package cbr;
import java.util.*;
public class OrdenacionFloat implements Comparator {
/** Compare two objects type Float
* @param obj1 Object for comparation
* @param obj2 Object for comparation
* @return 0 if are identic
*
<-1 if first object is smaller than second
*
>1 if first object in bigger than second
* @exception Not exceptions
*/
public int compare(Object obj1, Object obj2){
float f1 = ((Float)obj1).floatValue();
float f2 = ((Float)obj2).floatValue();
if(f1 > f2) {
return 1;
} else if (f1 < f2) {
return -1;
} else {
return 0;
}
}
}
*******************************************************************************************
OrdenacionInteger.java
*******************************************************************************************
/**
Class Ordenacioninteger
Programmer: Manuel Miguel Gimenez Arjona
169
Estudio para la implementación de un sistema de razonamiento basado en casos
Proyect:CBR Extraccion Module
Directors: Ivan Lopez Arevalo / Aïda Valls Mateu
Departament de Enginyeria Informatica i Matematiques
Universitat Rovira i Virgili
Date: 2.08.2005
*/
package cbr;
import java.util.*;
public class OrdenacionInteger implements Comparator {
/** Compare two objects type Integer
* @param obj1 Object for comparation
* @param obj2 Object for comparation
* @return 0 if are identic
*
<-1 if first object is smaller than second
*
>1 if first object in bigger than second
* @exception Not exceptions
*/
public int compare(Object obj1, Object obj2){
int i1 = ((Integer)obj1).intValue();
int i2 = ((Integer)obj2).intValue();
return Math.abs(i1) - Math.abs(i2);
}
}
*******************************************************************************************
OrdenacionNombre.java
*******************************************************************************************
/**
Class OrdenacionNombre
Programmer: Manuel Miguel Gimenez Arjona
Proyect:CBR Extraccion Module
Directors: Ivan Lopez Arevalo / Aïda Valls Mateu
Departament de Enginyeria Informatica i Matematiques
Universitat Rovira i Virgili
Date: 2.08.2005
*/
package cbr;
import java.util.*;
public class OrdenacionNombre implements Comparator {
*
*
*
*
*
*
/** Compare two objects type String
@param obj1 Object for comparation
@param obj2 Object for comparation
@return 0 if are indentic
<-1 if first object is smaller than second
>1 if first object in bigger than second
@exception Not exceptions
*/
public int compare( Object obj1,Object obj2 ) {
String s1 = ( (String)obj1.toString());
String s2 = ( (String)obj2.toString());
return( s1.compareTo( s2 ) );
}
170
Estudio para la implementación de un sistema de razonamiento basado en casos
}
*******************************************************************************************
OZoneProgram.java
*******************************************************************************************
/**
Class Ozone Program : Create Db ozone or open to casebase
Programmer: Manuel Miguel Gimenez Arjona
Proyect:CBR Extraccion Module
Directors: Ivan Lopez Arevalo / Aïda Valls Mateu
Departament de Enginyeria Informatica i Matematiques
Universitat Rovira i Virgili
Date: 2.08.2005
*/
package cbr;
import java.io.*;
import java.awt.*;
import java.util.*;
public class OzoneProgram {
/**main
*/
public static void main(String[] args) {
OzoneProgram application = new OzoneProgram();
application.run();
}
/**Run, Create main Window
* @param Not Param
* @exception Not Exceptions
*/
void run() {
int width=625, height=440; // relize
OzoneWindow mainWindow = new OzoneWindow();
Dimension sizePant=Toolkit.getDefaultToolkit().getScreenSize();
mainWindow.setLocation( (sizePant.width - width) / 2,
(sizePant.height - height) / 2);
mainWindow.setTitle("DATA BASE OZONE");
mainWindow.setResizable(false);
mainWindow.setSize(width,height);
mainWindow.show();
}
}
*******************************************************************************************
OZoneWindow.java
*******************************************************************************************
/**
Class OzeneWindow, Window for Open And create a new database Ozone
Programmer: Manuel Miguel Gimenez Arjona
Proyect:CBR Extraccion Module
Directors: Ivan Lopez Arevalo / Aïda Valls Mateu
Departament de Enginyeria Informatica i Matematiques
Universitat Rovira i Virgili
Date: 2.08.2005
*/
171
Estudio para la implementación de un sistema de razonamiento basado en casos
package cbr;
import java.io.*;
import java.awt.*;
import java.util.*;
import javax.swing.*;
import java.awt.event.*;
import javax.swing.table.*;
import javax.swing.event.*;
import javax.swing.border.*;
import net.sourceforge.selectionengine.SimilarityCriteria;
import net.sourceforge.selectionengine.SimilarityWeights;
import net.sourceforge.selectionengine.FilterCriteria;
import net.sourceforge.selectionengine.FilterEngine;
import net.sourceforge.selectionengine.Items;
import net.sourceforge.selectionengine.ItemManager;
import net.sourceforge.selectionengine.DataSetStatistics;
import net.sourceforge.selectionengine.SimilarItems;
import net.sourceforge.selectionengine.SimilarityEngine;
public class OzoneWindow extends JFrame{
//var
JMenuBar menuOp = new JMenuBar();
JMenu menuFile = new JMenu ("File");
JMenu menuHelp = new JMenu ("Help");
// JMenuItems
JMenuItem newCreateDb = new JMenuItem("Create DB Ozone");
JMenuItem connectionOzone = new JMenuItem("Open DB Ozone");
JMenuItem help = new JMenuItem("Help");
JMenuItem exit = new JMenuItem("Exit Program");
/**OzoneWindow
* @param Not Param
* @exception Exception printStrackTarce
*/
public OzoneWindow() {
try {
montar_Menubar(); // create menubars
ImageIcon imagen= new ImageIcon ("images/ozone.jpg");
JLabel label = new JLabel(imagen);
this.getContentPane().add(label);
}
catch(Exception e) {
e.printStackTrace();
}
}
/**Create the menubar of ozone Window
* @param Not Param
* @exception Not Exceptions
*/
public void montar_Menubar (){
// Group Menubar menuFile
menuFile.setMnemonic(KeyEvent.VK_F);
newCreateDb.setMnemonic(KeyEvent.VK_C);
menuFile.add(newCreateDb);
connectionOzone.setMnemonic(KeyEvent.VK_N);
menuFile.add(connectionOzone);
exit.setMnemonic(KeyEvent.VK_X);
menuFile.add(new JSeparator());
menuFile.add(exit);
172
Estudio para la implementación de un sistema de razonamiento basado en casos
menuHelp.add(help);
menuOp.add(menuFile);
menuOp.add(menuHelp);
// Event Help
help.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(ActionEvent e) {
help_actionPerformed(e);
}});
// Event Exit
exit.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(ActionEvent e) {
exit_actionPerformed(e);
}});
//Event Close
this.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
this.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e){
exitWindow(e);
}});
//Event Create new DBozone
newCreateDb.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(ActionEvent e) {
newCreateDb_actionPerformed(e);
}});
// connection
connectionOzone.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(ActionEvent e) {
connectionOzone_actionPerformed(e);
}});
this.setJMenuBar(menuOp);
}
/**help of Aplication
* @param ActionEvent e
* @exception Not Exceptions
*/
void help_actionPerformed(ActionEvent e) {
JOptionPane.showMessageDialog(this,
"CBR MODULE EXTRACTION\n" +
"*******************************\n" +
"PROGRAMMER:\n" +
"
Manuel Miguel Gimenez Arjona\n" +
"
manuelmiguel.gimenez@estudiants.urv.es\n\n" +
"DIRECTORS:\n" +
"
Ivan Lopez Arevalo / Aïda Valls Mateu\n" +
"
ivan.lopez@urv.net / aida.valls@urv.net\n\n" +
"LINKS:\n" +
"
[BANZAI Research Group]
http://www.etse.urv.es/recerca/banzai\n" +
"
[Dept. Enginyeria Informatica i Matematiques]
http://www.etse.urv.es/DEIM\n" +
"
[Universitat Rovira i Virgili]
http://www.urv.net\n" +
"
[Java]
http://www.java.sun.com\n" +
"
[Selection Engine]
http://selectionengine.sourceforge.net\n"
+
"
[Ozone Project]
http://www.ozone-db.org\n",
"ABOUT CBR..", JOptionPane.PLAIN_MESSAGE);
}
/**Create a new Database of Ozone
* @param ActionEvent e
* @exception Not Exceptions
*/
void newCreateDb_actionPerformed(ActionEvent e) {
173
Estudio para la implementación de un sistema de razonamiento basado en casos
JFileChooser jFileChooser = new JFileChooser();
String path = new String();
try{
// file chosser window
if (JFileChooser.APPROVE_OPTION == jFileChooser.showSaveDialog(this)) {
path = jFileChooser.getSelectedFile().getPath();
String fileName = "iniozone" +
jFileChooser.getSelectedFile().getName() + ".bat";
File f = new File(fileName);
if ( f.exists()){ // if file.bat exist
JOptionPane.showMessageDialog( this, "Data base exist",
null, JOptionPane.ERROR_MESSAGE
);
}
else { // if file.bat not exist
FileOutputStream file = new FileOutputStream(fileName);
String createDb = new String();
createDb = "ozone -d" + path +" -c";
// create path
file.write(createDb.getBytes());
file.close();
this.setVisible(false);
this.removeAll();
String fileNameConnect = "ConectOzone" +
jFileChooser.getSelectedFile().getName() + ".bat";
FileOutputStream fileNew = new
FileOutputStream(fileNameConnect);
String conectDb = new String();
conectDb = "ozone -d" + path; // create path
fileNew.write(conectDb.getBytes());
fileNew.close();
CmdExec("libraries.bat"); // libraries run for Ozone
CmdExec(fileName);
}
}
}catch (Exception excep) {
JOptionPane.showMessageDialog( this, "Error: " + excep,
"Error", JOptionPane.ERROR_MESSAGE );
}
}
/**Connection Database of Ozone
* @param ActionEvent e
* @exception Not Exceptions
*/
void connectionOzone_actionPerformed(ActionEvent e) {
JFileChooser jFileChooser = new JFileChooser();
String path = new String();
try{
ExampleFileFilter filter = new ExampleFileFilter();
filter.addExtension("bat");
jFileChooser.setFileFilter(filter);
174
Estudio para la implementación de un sistema de razonamiento basado en casos
if (JFileChooser.APPROVE_OPTION == jFileChooser.showOpenDialog(this)) {
String fileName = jFileChooser.getSelectedFile().getName();
this.setVisible(false);
this.removeAll();
CmdExec("libraries.bat"); // execute libraries needed
CmdExec(fileName);
// execute file.bat
}
}catch (Exception excep) {
JOptionPane.showMessageDialog( this, "Error: " + excep,
"Error", JOptionPane.ERROR_MESSAGE );
}
}
/**Exit program
* @param ActionEvent e
* @exception Not Exceptions
*/
void exit_actionPerformed(ActionEvent e) {
if (JOptionPane.showConfirmDialog(this,"Are you sure to Exit?","Exit
Program",JOptionPane.YES_NO_OPTION) == JOptionPane.YES_OPTION){
System.exit(0);
}
}
/**Exit window
* @param ActionEvent e
* @exception Not Exceptions
*/
void exitWindow(WindowEvent e){
if(JOptionPane.showConfirmDialog(this,"Are you sure to Exit?",
"ExitProgram",JOptionPane.YES_NO_OPTION)
==JOptionPane.YES_OPTION){
System.exit(0);
}
}
/**Execute .bat, Code for execute file.bat
* @param String cmdline, file .bat for execute
* @exception exception printStackTrace
*/
public void CmdExec(String cmdline) {
try {
String line;
Process p = Runtime.getRuntime().exec(cmdline);
Runtime.getRuntime().gc();
BufferedReader input =
new BufferedReader
(new InputStreamReader(p.getInputStream()));
while ((line = input.readLine()) != null) {
System.out.println(line);
}
input.close();
}
catch (Exception err) {
err.printStackTrace();
}
}
}
*******************************************************************************************
RepositoryOzone.java
*******************************************************************************************
**
175
Estudio para la implementación de un sistema de razonamiento basado en casos
Class RepositoyOzone, reload cases, open, close & save cases in casebase Ozone
Programmer: Manuel Miguel Gimenez Arjona
Proyect:CBR Extraccion Module
Directors: Ivan Lopez Arevalo / Aïda Valls Mateu
Departament de Enginyeria Informatica i Matematiques
Universitat Rovira i Virgili
Date: 2.08.2005
*/
package cbr;
import java.io.*;
import java.util.*;
import javax.swing.*;
import org.ozoneDB.*;
public class RepositoryOzone {
ExternalDatabase db;
GetInfo InfoCases;
/**RepositoryOzone
* @param Not Param
* @exception Not Exceptions
*/
public RepositoryOzone() {
}
/**open dataBase
* @param Not Param
* @exception Exception
*/
public void open() throws Exception {
db = ExternalDatabase.openDatabase( "ozonedb:remote://localhost:3333" );
}
/**Close DataBase
* @param Not Param
* @exception Not Exceptions
*/
public void close() throws Exception {
db.close();
JOptionPane.showMessageDialog( null, "Disconect DataBase Ozone",
"Information",
JOptionPane.INFORMATION_MESSAGE );
}
/**Create Cases from File.dat
* @param Not Param
* @exception Exception, Not exist
*/
public void create() throws Exception {
try{
InfoCases = new GetInfo( "Dvd_Catalog.dat",db );
} catch(Exception e){
JOptionPane.showMessageDialog( null, "Error: Not exist File",
"Information",
JOptionPane.INFORMATION_MESSAGE );
176
Estudio para la implementación de un sistema de razonamiento basado en casos
}
}
/**Get Cases of DataBase
* @param Not Param
* @exception Exception, Not cases
*/
public ArrayList getCases(JFrame frame) throws Exception {
ArrayList listReturn = new ArrayList();
try {
CasesGroup casesGroup = (CasesGroup)(db.objectForName("Collection")); //
Object collection cases ozone
listReturn = casesGroup.getCases(); // collection of cases
} catch(Exception e){
CasesGroup casesGroup =
(CasesGroup)(db.createObject(CasesGroupImpl.class.getName(), 0,"Collection"));
JOptionPane.showMessageDialog(frame, "DataBase don't have cases",
"Information",
JOptionPane.INFORMATION_MESSAGE );
}
return listReturn;
}
/**delete Case in database Ozone
* @param int index, index of case
* @exception Exception, error
*/
public void deleteCase(int index){
CasesGroup casesGroup;
try{
casesGroup = (CasesGroup)(db.objectForName("Collection"));
casesGroup.removeCases(index); // remove case
} catch(Exception e){
JOptionPane.showMessageDialog( null, "Error:" + e,
"Information",
JOptionPane.INFORMATION_MESSAGE );
}
}
/**Edit Case in database Ozone
* @param int index, index of case
* @param CasesImpl caseObtain, caseObtain for edit
* @exception Exception, error
*/
public void EditCase(int index, CasesImpl caseObtain){
CasesGroup casesGroup;
try{
casesGroup = (CasesGroup)(db.objectForName("Collection")); // object collection
casesGroup.insertCase(index, caseObtain); // edit case
} catch(Exception e){
JOptionPane.showMessageDialog( null, "Error:" + e,
"Information",
177
Estudio para la implementación de un sistema de razonamiento basado en casos
JOptionPane.INFORMATION_MESSAGE );
}
}
/**Save Case obtain in database Ozone
* @param CasesImpl caseObtain, caseObtain for insert
* @exception Exception, error
*/
public void saveCaseObtain(CasesImpl caseObtain){
CasesGroup casesGroup;
try{
casesGroup = (CasesGroup)(db.objectForName("Collection")); // object Collection
casesGroup.addCases(caseObtain);
// save case
} catch(Exception e){
casesGroup = (CasesGroup)(db.createObject(CasesGroupImpl.class.getName(),
0,"Collection"));
JOptionPane.showMessageDialog( null, "Error:" + e,
"Information",
JOptionPane.INFORMATION_MESSAGE );
}
}
/**Save metadata case en data base
* @param ArrayList listMeta, list of metacases
* @exception Exception, not collection iniciated
*/
public void saveDataBase(JFrame frame, ArrayList listMeta) throws Exception {
MetaInfoGroup metaInfoGroup;
try{
metaInfoGroup = (MetaInfoGroup)(db.objectForName("MetaCollection")); //object collection
// METADATOS
db.deleteObject(metaInfoGroup); // delete
metaInfoGroup = (MetaInfoGroup)(db.createObject(MetaInfoGroupImpl.class.getName(),
0,"MetaCollection"));
Iterator itMeta = listMeta.iterator();
while (itMeta.hasNext()) { // insert
MetaInfoImpl metaInfoNew = (MetaInfoImpl)itMeta.next();
metaInfoGroup.addMeta(metaInfoNew);
}
} catch(Exception e){
//object collection of metacases
metaInfoGroup = (MetaInfoGroup)(db.createObject(MetaInfoGroupImpl.class.getName(),
0,"MetaCollection"));
Iterator itMeta = listMeta.iterator();
while (itMeta.hasNext()) { //insert
MetaInfoImpl metaInfoNew = (MetaInfoImpl)itMeta.next();
metaInfoGroup.addMeta(metaInfoNew);
178
Estudio para la implementación de un sistema de razonamiento basado en casos
}
}
}
/**Get metacases of database
* @param Not Param
* @exception Exception, Not metainformation
*/
public ArrayList getMeta(JFrame frame) throws Exception {
ArrayList listReturn = new ArrayList();
try {
//object collection of metacases
MetaInfoGroup metaInfoGroup =
(MetaInfoGroup)(db.objectForName("MetaCollection"));
listReturn = metaInfoGroup.getMeta(); // return list of metacases
} catch(Exception e){
MetaInfoGroup metaInfoGroup =
(MetaInfoGroup)(db.createObject(MetaInfoGroupImpl.class.getName(),
0,"MetaCollection"));
JOptionPane.showMessageDialog( frame, "DataBase don't have a Metadata
Information",
"Information",
JOptionPane.INFORMATION_MESSAGE );
}
return listReturn;
}
}
*******************************************************************************************
ResultsVindow.java
*******************************************************************************************
/**
Class ResultsWindow, window results similarity, This Window show the similar cases that
criterion of user in query window.
Programmer: Manuel Miguel Gimenez Arjona
Proyect:CBR Extraccion Module
Directors: Ivan Lopez Arevalo / Aïda Valls Mateu
Departament de Enginyeria Informatica i Matematiques
Universitat Rovira i Virgili
Date: 2.08.2005
*/
package cbr;
import
import
import
import
import
import
import
import
import
import
java.io.*;
java.awt.*;
java.util.*;
javax.swing.*;
java.awt.event.*;
java.awt.print.*;
java.text.DecimalFormat;
java.awt.print.PrinterJob;
net.sourceforge.selectionengine.*;
javax.swing.table.AbstractTableModel;
import javax.swing.table.DefaultTableCellRenderer;
import javax.swing.table.TableCellRenderer;
import javax.swing.table.TableColumn;
public class ResultsWindow extends JPanel implements Printable{
//var
179
Estudio para la implementación de un sistema de razonamiento basado en casos
int MAX_CASES_DISPLAYED = 30; // max cases show
JEditorPane resultsEditorPane = new JEditorPane();
JFrame frame;
String results = "null";
SimilarItems similarItemsInfo = new SimilarItems();
TraitDescriptors traitDescriptorsInfo = new TraitDescriptors();
/** ResultsWindow
* @param JFrame frameOriginal, frame main window
* @param ArrayList listView, List of metaCases
* @param SimilarItems similarItems, Class of similar items
* @param TraitDescriptors TraitDescriptors, Descritors of attributes
* @param int maxCases, integer of max cases show
* @param boolean similarity, true or false prefer serach user
* @exception Exception error in windowProve
*/
public ResultsWindow(JFrame frameOriginal, ArrayList listView, SimilarItems
similarItems, TraitDescriptors traitDescriptors, int maxCases, boolean similarity)
{//throws Exception
try{
frame = frameOriginal;
Container contentPaneDialog;
// JPanel & Butons
JPanel resultsPanel = new JPanel();
JPanel buttonPanel = new JPanel();
JButton okButton = new JButton();
JButton cancelButton = new JButton();
JButton printButton = new JButton();
JButton saveButton = new JButton();
final JTable tableResults;
JScrollPane scrollPane;
this.similarItemsInfo = similarItems;
this.traitDescriptorsInfo = traitDescriptors;
MAX_CASES_DISPLAYED = maxCases; // max similar cases Show
JPanel titlePanel = new JPanel();
ImageIcon imagen= new ImageIcon ("images/DibujoResultsSimilarity.jpg");
JLabel labelTitle = new JLabel(imagen);
final JDialog dialog = new JDialog(frame);
resultsPanel.setLayout(new BorderLayout());
resultsPanel.setBorder(BorderFactory.createEmptyBorder(20,20,20,20));
// title of dialog
dialog.setTitle("Case-based Reasoning Module - Results");
displayResults dispResult = new displayResults(frame, listView, similarItems,
traitDescriptors, similarity);
tableResults = new JTable(dispResult); // results of similar cases
this.results = dispResult.getHtml(); // get code Html for save results
tableResults.setBackground(Color.lightGray);
// mouse listener
tableResults.addMouseListener(new MouseAdapter(){
public void mouseClicked(MouseEvent e){
if (e.getClickCount() == 2){
Point p = e.getPoint();
infoTable_action(tableResults.rowAtPoint(p));
}
}
});
scrollPane = new JScrollPane(tableResults);
if (similarItems.size() <= 0){
JPanel noResultsPanel = new JPanel();
noResultsPanel.add(new JLabel("There are not similar cases. "));
noResultsPanel.add(new JLabel("The data you have entered might be
inconsistent or incorrect. "));
180
Estudio para la implementación de un sistema de razonamiento basado en casos
noResultsPanel.add(new JLabel("Try again"));
resultsPanel.add(noResultsPanel, BorderLayout.CENTER);
}else{
resultsPanel.add(scrollPane, BorderLayout.CENTER);
}
// buttons
okButton.setText("Ok");
okButton.setBounds(100,20,100,20);
okButton.addActionListener(new java.awt.event.ActionListener(){
public void actionPerformed(ActionEvent e){
dialog.dispose();
}
});
saveButton.setText("Save Results");
saveButton.setBounds(100,20,100,20);
saveButton.addActionListener(new java.awt.event.ActionListener(){
public void actionPerformed(ActionEvent e) {
SaveButton_actionPerformed(e);
}
});
buttonPanel.add(okButton, null);
buttonPanel.add(saveButton, null);
buttonPanel.setLayout(new FlowLayout());
buttonPanel.add(okButton);
buttonPanel.add(saveButton);
//insert in dialog
dialog.getContentPane().add(labelTitle,BorderLayout.NORTH);
dialog.getContentPane().add(resultsPanel, BorderLayout.CENTER);
dialog.getContentPane().add(buttonPanel,BorderLayout.SOUTH);
dialog.setSize(new Dimension(850, 465));
dialog.setLocationRelativeTo(frame);
dialog.setVisible(true);
}catch (Exception excep) {
JOptionPane.showMessageDialog( frame, "Error: " + excep,
"Error", JOptionPane.ERROR_MESSAGE );
}
}
/** Window iformation of one case, Show one case with all Attributes and values
* @param int row, row of table
* @exception Not Exception
*/
public void infoTable_action(int row){
WindowCasesInfo infoCases = new WindowCasesInfo(row, this.similarItemsInfo,
this.traitDescriptorsInfo);
}
/** Save Cases in file.html
* @param ActionEvent e
* @exception Exception
*/
public void SaveButton_actionPerformed( ActionEvent e ) {
JFileChooser jFileChooser = new JFileChooser();
String path = new String();
ExampleFileFilter filter = new ExampleFileFilter();
filter.addExtension("html");
jFileChooser.setFileFilter(filter);
try{
if (JFileChooser.APPROVE_OPTION == jFileChooser.showSaveDialog(this)) {
path = jFileChooser.getSelectedFile().getPath() + ".html";
FileOutputStream file = new FileOutputStream(path);
file.write(this.results.getBytes());
file.close();
JOptionPane.showMessageDialog( frame, "Save results succesful",
"Svae",
JOptionPane.INFORMATION_MESSAGE );
}
181
Estudio para la implementación de un sistema de razonamiento basado en casos
}catch (Exception excep) {
JOptionPane.showMessageDialog( frame, "Error: " + excep,
"Error", JOptionPane.ERROR_MESSAGE );
}
}
/** Print
* @param ActionEvent evnt
* @exception Exception printStackTrace
*/
public void PrintButton_actionPerformed( ActionEvent evnt ) {
PrinterJob printJob = PrinterJob.getPrinterJob();
printJob.setPrintable(this);
if( printJob.printDialog() ) {
try {
printJob.print();
} catch( PrinterException e ) {
e.printStackTrace();
}
}
}
/** metod aux
* @param ActionEvent e
* @exception Not Exception
*/
public int print( Graphics g,PageFormat pf,int pi ) {
if( pi >= 1 ){
return( NO_SUCH_PAGE );
}
pi = 1;
Graphics2D g2 = (Graphics2D)g;
g2.translate( pf.getImageableX(),pf.getImageableY() );
Rectangle componentBounds = this.resultsEditorPane.getBounds(null);
g2.translate(-componentBounds.x, -componentBounds.y);
g2.scale(0.5, 0.5);
this.resultsEditorPane.paint(g2);
return PAGE_EXISTS;
}
//***************************************************************************
//***************************************************************************
/**
Class DisplayResults, for create a abstractTableModel
Programmer: Manuel Miguel Gimenez Arjona
Proyect:CBR Extraccion Module
Directors: Ivan Lopez Arevalo / Aïda Valls Mateu
Departament de Enginyeria Informatica i Matematiques
Universitat Rovira i Virgili
Date: 2.08.2005
*/
class displayResults extends AbstractTableModel{
//var
private Vector columnNames = new Vector(1,1);
private Vector data = new Vector(1,1); //rows
private int counter = 0;
private TraitDescriptor traitDescriptor;
private SimilarityDescription similarityDescription;
private int percentSimilarity, rank;
private String HTML = new String("");
private String traitName, value, align = "";
private Iterator cursor;
private Item item;
String htmlInfo;
private JFrame frame;
182
Estudio para la implementación de un sistema de razonamiento basado en casos
/** DisplayResults
* @param JFrame jframe, jframe
* @param ArrayList listView, List of metaCases
* @param SimilarItems similarItems, Class of similar items
* @param TraitDescriptors TraitDescriptors, Descritors of attributes
* @param boolean similarity, user indicate similarity prefer?
* @exception Not Exception
*/
public displayResults( JFrame frameX,ArrayList listView, SimilarItems items,
TraitDescriptors traitDescriptors, boolean similarity ){// p/Sustances
String results = "null";;
int i, j, counter, descriptorSize = traitDescriptors.size();
this.frame = frameX;
// code html is sabe in String
HTML = HTML + "<title>Results of Similar Cases</title>";
HTML = HTML + "<CENTER><font " + "face=arial" + " size=10>CBR - EXTRACTION
MODULE</font> </CENTER>";
HTML = HTML + "<CENTER><font " + "face=arial" + " size=2>Results of Similar
Cases</font> </CENTER>";
HTML = HTML + "<table border=2 align=center cellspacing=0
bordercolor=#000000>";
//--- Column headers
HTML = HTML + "<tr>";
HTML = HTML + "<th " + "align=center" + " bgcolor=#FF9900" + "><font " +
"color=#FFFFFF" + "</font>";
HTML = HTML + "Rank";
HTML = HTML + "</th>";
HTML = HTML + "<th " + "align=center" + " bgcolor=#99CC00" + "><font " +
"color=#FFFFFF" + "</font>";
HTML = HTML + "Similarity";
HTML = HTML + "</th>";
// column Names special
columnNames.add("Rank");
columnNames.add("Similarity");
for (i=0; i < descriptorSize; i++ ) { // descriptors
traitDescriptor = traitDescriptors.get( i );
traitName = traitDescriptor.getName();
if (traitDescriptor.getIncluded()== true){ // is visible attribute?
HTML = HTML + "<th " + "align=center" + " bgcolor=#0099CC" + "><font
" + "color=#FFFFFF" + "</font>";
HTML = HTML + traitName;
HTML = HTML + "</th>";
columnNames.add(traitName);
}
}
counter = 0;
int numCasesDisplayed = 1;
cursor = items.iterator();
while ( (cursor.hasNext()) && (numCasesDisplayed <= MAX_CASES_DISPLAYED) ) { //
while exist items &
Vector columns = new Vector(1,1);
//
numCasesDisplayed <= MaxCASES
similarityDescription = (SimilarityDescription) cursor.next(); // next item
Similar
percentSimilarity = (int) (100 *
similarityDescription.getPercentSimilarity()); // create %
rank = similarityDescription.getRank();
item = similarityDescription.getItem();
if (percentSimilarity != 0 || similarity == false){ //if is diferent of 0%
HTML = HTML + "<tr>";
HTML = HTML + "<td>";
HTML = HTML + rank ;
183
Estudio para la implementación de un sistema de razonamiento basado en casos
HTML = HTML + "</td>";
HTML = HTML + "<td align=center>";
HTML = HTML + percentSimilarity + " %";
HTML = HTML + "</td>";
columns.add( String.valueOf(rank) );
columns.add(percentSimilarity + " %");
Iterator itraits = listView.iterator();
for (i=0; i < descriptorSize; i++ ) { // for all Attributes of case
traitDescriptor = traitDescriptors.get( i );
traitName = traitDescriptor.getName();
align = "align=center";
//--- Let's get that trait in the current item
if (traitDescriptor.getIncluded()== true){
value = item.getTraitValue( traitName ).value();
HTML = HTML + "<td " + align + ">";
HTML = HTML + value;
HTML = HTML + "</td>";
columns.add(value);
}
}
//--- for i=0 to fields.size
HTML = HTML +
"</tr>";
//
value += " %";
columns.add(value);
data.add(columns); // add to data
counter++;
numCasesDisplayed ++;
}
} //--- while hasNext
HTML = HTML + "</table>";
results = HTML;
htmlInfo = results;
}//constructor
/** get Html
* @param not params
* @return return String, String contain Code html
* @exception Not Exception
*/
public String getHtml() {
return htmlInfo;
}
/** get colum size
* @param Not params
* @return return int, Vector size
* @exception Not Exception
*/
public int getColumnCount() {
return columnNames.size();
}
/** get data size
* @param Not params
* @return return int, data size
* @exception Not Exception
*/
public int getRowCount() {
return data.size();
}
184
Estudio para la implementación de un sistema de razonamiento basado en casos
/** get column Name
* @param int col, index of column
* @return return String, name of column
* @exception Not Exception
*/
public String getColumnName(int col) {
return (String)columnNames.elementAt(col);
}
/** get object
* @param int row, index of row
* @param int col, index of column
* @return return object, object that contain position
* @exception Not Exception
*/
public Object getValueAt(int row, int col) {
return ((Vector)data.elementAt(row)).elementAt(col);
}
/** is editable?
* @param EventObject evt
* @return return boolean, false is editable
* @exception Not Exception
*/
public boolean isCellEditable(EventObject evt) {
return false;
}
}
}
//--- ResultsWindow
*******************************************************************************************
SimilarItems.java
*******************************************************************************************
/**
This class save a collection of similar Items, This items are the percent similarity
bigger in all items. items are order by percent similarity
This class has been modified to comment the methods
modified by Manuel Miguel Gimenez Arjona
*/
package net.sourceforge.selectionengine;
import java.util.*;
/**
*
* @author <small>baylor</small>
*
*/
public class SimilarItems {
//----------------------------------------------------------------------------// Attributes
//----------------------------------------------------------------------------//--- Sorted list of SimilarityDescription objects
private ArrayList descriptions = new ArrayList();
//----------------------------------------------------------------------------// Methods
//----------------------------------------------------------------------------/** add collection similar items
* @param SimilarityDescription descriptor, item similarity
185
Estudio para la implementación de un sistema de razonamiento basado en casos
* @exceptions Not Exceptions
*/
protected void add( SimilarityDescription descriptor ) {
descriptions.add( descriptor );
} //--- add
/** return SimilarityDescription, get bestmatch
* @param not params
* @return SimilarityDescription descriptor
* @exceptions Not Exceptions
*/
public SimilarityDescription getBestMatch( ) {
SimilarityDescription descriptor =
(SimilarityDescription) descriptions.get( 0 );
}
return descriptor;
//--- getBestMatch
/** return SimilarItems bestmatches
* @param int numberOf maches, integer Items filtered
* @return SimilarItems, SimilarItems filtererd
* @exceptions Not Exceptions
*/
public SimilarItems getBestMatches( int numberOfMatches ) {
SimilarItems subset = new SimilarItems();
if (numberOfMatches > descriptions.size()) {
numberOfMatches = descriptions.size();
}
for (int i=0; i < numberOfMatches; i++ ) {
SimilarityDescription description =
(SimilarityDescription) descriptions.get( i
);
subset.add( description );
}
}
return subset;
//--- getBestMatches
/** return SimilarItems ByPercentSimilarity
* @param float percentSimilar, percent similarity Item
* @return SimilarItems, SimilarItems filtererd
* @exceptions Not Exceptions
*/
public SimilarItems getByPercentSimilarity( float percentSimilar ) {
SimilarItems subset = new SimilarItems();
for (int i=0; i < descriptions.size(); i++ ) {
SimilarityDescription description =
(SimilarityDescription) descriptions.get( i
);
if (description.getPercentSimilarity() ==
percentSimilar) {
subset.add( description );
}
}
}
return subset;
//--- getByPercentSimilarity
/** return SimilarItems ByRank
* @param int rank, integer rank of item
* @return SimilarItems, SimilarItems filtererd
* @exceptions Not Exceptions
*/
public SimilarItems getByRank( int rank ) {
SimilarItems subset = new SimilarItems();
for (int i=0; i < descriptions.size(); i++ ) {
SimilarityDescription description =
(SimilarityDescription) descriptions.get( i
);
if (description.getRank() == rank) {
186
Estudio para la implementación de un sistema de razonamiento basado en casos
subset.add( description );
}
}
}
return subset;
//--- getByRank
/** return ByRelativeRank
* @param fint rank, integer rank of item
* @return SimilarDescrition, SimilarDescrition item
* @exceptions Not Exceptions
*/
public SimilarityDescription getByRelativeRank( int rank ) {
int index = rank - 1;
//--- 0 based array
SimilarityDescription descriptor =
(SimilarityDescription) descriptions.get( index );
}
return descriptor;
//--- getByRelativeRank
/** return SimilarItems ByThreshold
* @param float minimumPercentSimilar, min pecent similar item
* @return SimilarItems, SimilarItems filtererd
* @exceptions Not Exceptions
*/
public SimilarItems getByThreshold( float minimumPercentSimilar ) {
SimilarItems subset = new SimilarItems();
for (int i=0; i < descriptions.size(); i++ ) {
SimilarityDescription description =
(SimilarityDescription) descriptions.get( i
);
if (description.getPercentSimilarity() >=
minimumPercentSimilar) {
subset.add( description );
}
}
}
return subset;
//--- getByThreshold
/** return isEmpty
* @param not param
* @return boolean is Empty
* @exceptions Not Exceptions
*/
public boolean isEmpty() {
return false;
}
/** return iterator
* @param not param
* @return Iterator
* @exceptions Not Exceptions
*/
public Iterator iterator() {
return descriptions.iterator();
}
/** put rank Items
* @param not param
* @exceptions Not Exceptions
*/
public void rankItems() {
try {
Collections.sort( this.descriptions );
//--- Hopefully now the index is the also the sort order
//--so we'll use it for our ranking
for (int i=0; i < descriptions.size(); i++ ) {
SimilarityDescription description =
(SimilarityDescription)
descriptions.get( i );
int rank = i + 1;
187
//--- +1 to compensate
Estudio para la implementación de un sistema de razonamiento basado en casos
}
for 0-based arrays
description.setRank( rank );
//--- for i=0 to fields.size
}
catch (Exception e) {
System.out.println( "exception: " + e );
e.printStackTrace();
} //--- catch
}
//--- rankItems
/** return size collection
* @param not param
* @return int size
* @exceptions Not Exceptions
*/
public int size() {
return descriptions.size();
} //--- size
}
//--- SimilarItems
*******************************************************************************************
SimilarityCriteria.java
*******************************************************************************************
/**
This class save a collection of SimilarityCriterion objects,
This collection are all criterion similarty definited by user
This class has been modified to comment the methods
modified by Manuel Miguel Gimenez Arjona
*/
package net.sourceforge.selectionengine;
import java.util.*;
/**
*
* @author <small>baylor</small>
*/
public class SimilarityCriteria {
private ArrayList criteria = new ArrayList();
/** add to collection SimilarCriterion
* @param SimilarityCriterion criterion
* @exceptions Not Exceptions
*/
public void add( SimilarityCriterion criterion ) {
criteria.add( criterion );
} //--- add
/** add to collection SimilarCriterion
* @param String fieldName, name Attribute
* @param String operator, operator
* @param String value, Value attribute
* @exceptions Not Exceptions
*/
public void add( String fieldName, String operator, String value ) {
SimilarityCriterion criterion =
new SimilarityCriterion( fieldName, operator, value );
this.add( criterion );
} //--- add
/** Clone object
* @param not param
* @return object
* @exceptions Not Exceptions
188
Estudio para la implementación de un sistema de razonamiento basado en casos
*/
public Object clone( ) {
SimilarityCriteria newItems = new SimilarityCriteria();
newItems.setValues( criteria );
}
return (Object) newItems;
//--- clone
/** Return iterator
* @param not param
* @return Iterator
* @exceptions Not Exceptions
*/
public Iterator iterator() {
return criteria.iterator();
} //--- iterator
/** Set values new
* @param ArrayList newValues, new values
* @exceptions Not Exceptions
*/
protected void setValues( ArrayList newValues ) {
criteria = (ArrayList) newValues.clone();
} //--- setValues
/** Set integer size of array list
* @param not param
* @exceptions Not Exceptions
*/
public int size() {
return criteria.size();
} //--- size
}
//--- SimilarityCriteria
*******************************************************************************************
SimilarityCriterion.java
*******************************************************************************************
/**
This class save one criterion similarity, each criterion similarity
defined by user is one object SimilarityCriterion. This class save one attribute,
the operator special of similarity and the value of attribute
This class has been modified to comment the methods
modified by Manuel Miguel Gimenez Arjona
*/
package net.sourceforge.selectionengine;
public class SimilarityCriterion
{
//----------------------------------------------------------------------------// Public constants
//----------------------------------------------------------------------------public static final int OPERATOR_UNKNOWN
= 0;
public static final int OPERATOR_SIMILAR
= 1;
public static final int OPERATOR_NOT_SIMILAR
= 2;
public static final int OPERATOR_AROUND
//----------------------------------------------------------------------------// Attributes
//----------------------------------------------------------------------------private String
fieldName;
private int
operator;
private TraitValue value;
//----------------------------------------------------------------------------// Constructors
189
= 3;
Estudio para la implementación de un sistema de razonamiento basado en casos
//----------------------------------------------------------------------------protected SimilarityCriterion( String fieldName, String operator, String value )
{
this.fieldName = fieldName;
this.operator = stringToOperator( operator );
this.value
= new TraitValue( value );
}
//----------------------------------------------------------------------------// Methods
//----------------------------------------------------------------------------/** Get Special Operator
* @param int operator. operator
* @Return string OperatorValue
* @exceptions Not Exceptions
*/
private String operatorToString( int operator )
{
String stringValue = null;
if (operator == OPERATOR_SIMILAR) {
stringValue = "%";
}
else if (operator == OPERATOR_NOT_SIMILAR) {
stringValue = "!%";
}
else if (operator == OPERATOR_AROUND) {
stringValue = "~";
} //--- figure out the operator
}
return stringValue;
//--- operatorToString
/** Get Special Operator
* @param String operator. operator
* @Return int OperatorValue
* @exceptions Not Exceptions
*/
private int stringToOperator( String operator )
{
int numericValue = OPERATOR_UNKNOWN;
if (operator.equals( "%" )) {
numericValue = OPERATOR_SIMILAR;
}
else if (operator.equals( "!%" )) {
numericValue = OPERATOR_NOT_SIMILAR;
}
else if (operator.equals( "~" )) {
numericValue = OPERATOR_AROUND;
} //--- figure out the operator
}
return numericValue;
//--- stringToDataType
//----------------------------------------------------------------------------// Accessors
//----------------------------------------------------------------------------/** Get String Attribute
* @param not params
* @Return string Attribute
* @exceptions Not Exceptions
*/
public String getFieldName()
{
return this.fieldName;
}
/** Get ID
* @param not params
* @Return string Id "[" + fieldName + "|" + getOperatorAsString() + "|" + value + "]"
* @exceptions Not Exceptions
*/
public String getID()
190
Estudio para la implementación de un sistema de razonamiento basado en casos
{
return "[" + fieldName + "|" + getOperatorAsString() + "|" + value +
"]";
}
/** Get Operator
* @param not params
* @Return Int operaror
* @exceptions Not Exceptions
*/
public int getOperator()
{
return this.operator;
}
/** Transform operator As String
* @param not params
* @Return String Operator
* @exceptions Not Exceptions
*/
public String getOperatorAsString()
{
return operatorToString( this.operator );
}
/** Get trait Value
* @param not params
* @Return Trait Value
* @exceptions Not Exceptions
*/
public TraitValue getValue()
{
return this.value;
}
}
//--- SimilarityCriterion
*******************************************************************************************
SimilarityCriterionScore.java
*******************************************************************************************
/*
This class SimilarityCriterionScore save the attribute operator and the value required by
user experience This group of objects are required in the search
This class has been modified to comment the methods
modified by Manuel Miguel Gimenez Arjona
*/
package net.sourceforge.selectionengine;
/**
*
* @author <small>baylor</small>
*
*/
public class SimilarityCriterionScore {
//----------------------------------------------------------------------------// Attributes
//----------------------------------------------------------------------------private String criterionID;
private float normalizedValue;
private float weightedValue;
//----------------------------------------------------------------------------// Constructors
//----------------------------------------------------------------------------protected SimilarityCriterionScore( String criterionID ) {
setID( criterionID );
}
//-----------------------------------------------------------------------------
191
Estudio para la implementación de un sistema de razonamiento basado en casos
// Accessors
//----------------------------------------------------------------------------/** Get Normalized value
* @param Not params
* @Return float normalizedValue, value normalized
* @exceptions Not Exceptions
*/
public float getNormalizedValue() {
return normalizedValue;
}
/** Set Normalized value
* @param Float value, value normalized
* @exceptions Not Exceptions
*/
protected void setNormalizedValue( float value ) {
this.normalizedValue = value;
}
/** Get ID "[" + fieldName + "|" + getOperatorAsString() + "|" + value + "]"
* @param Not params
* @Return String CriterionID
* @exceptions Not Exceptions
*/
public String getID() {
return criterionID;
}
/** Set ID
* @param String criterionID, "[" + fieldName + "|" + getOperatorAsString() + "|" +
value + "]"
* @exceptions Not Exceptions
*/
protected void setID( String criterionID ) {
this.criterionID = criterionID;
}
/** Get weight
* @param Not params
* @Return float weightedValue, value weight
* @exceptions Not Exceptions
*/
public float getWeightedValue() {
return weightedValue;
}
/** Set Weight
* @param float value, value Weight
* @exceptions Not Exceptions
*/
protected void setWeightedValue( float value ) {
this.weightedValue = value;
}
}
//--- SimilarityCriterionScore
*******************************************************************************************
SimilarityCriterionScores.java
*******************************************************************************************
/**
This class save a one collection of objects SimilarityCriterionScore,
SimilarityCriterionScore save the attribute operator and the value required by
user. This class is applicated in require criterions
*/
package net.sourceforge.selectionengine;
import java.util.*;
/**
*
* @author <small>baylor</small>
*
*/
192
Estudio para la implementación de un sistema de razonamiento basado en casos
public class SimilarityCriterionScores {
//----------------------------------------------------------------------------// Attributes
//----------------------------------------------------------------------------private HashMap scores = new HashMap();
//----------------------------------------------------------------------------// Methods
//----------------------------------------------------------------------------/** Add SimilarityCriterionScore at HashMap
* @param SimilarityCriterionScore score, Score normalize
* @exceptions Not Exceptions
*/
public void add( SimilarityCriterionScore score ) {
this.scores.put( score.getID(), score );
} //--- add
/** get SimilarityCriterionScore
* @param String ID, "[" + fieldName + "|" + getOperatorAsString() + "|" + value + "]"
* @return SimilarityCriterionScore
* @exceptions Not Exceptions
*/
public SimilarityCriterionScore get( String ID ) {
return (SimilarityCriterionScore) scores.get( ID );
} //--- get
/** return Iterator
* @param Not param
* @return Iterator
* @exceptions Not Exceptions
*/
public Iterator iterator() {
return scores.values().iterator();
} //--- iterator
/** return Int
* @param Not param
* @return int Scores
* @exceptions Not Exceptions
*/
public int size() {
return scores.size();
} //--- size
}
*******************************************************************************************
SimilarityDescription.java
*******************************************************************************************
/**
This class compare this percent of similar items for order from bigger to smaller
percent of Items
This class has been modified to comment the methods
modified by Manuel Miguel Gimenez Arjona
*/
package net.sourceforge.selectionengine;
/**
*
* @author <small>baylor</small>
*
*/
public class SimilarityDescription implements Comparable {
//----------------------------------------------------------------------------// Attributes
//----------------------------------------------------------------------------private Item itemBeingDescribed;
193
Estudio para la implementación de un sistema de razonamiento basado en casos
private int rank;
private float percentMatch;
//----------------------------------------------------------------------------// Methods
//----------------------------------------------------------------------------/**
* Implements the compareTo method required by the Comparable interface
* We're gonna compare items based on their percent similarity
* Used by SimilarItems.rankItems()
* The stupid argument name (o) is Sun's fault, not mine
*
* Return codes:
*
me > arg = -1 (better % match means we go first)
*
me = arg = 0
*
me < arg = +1 (it's a better match, it goes first)
*/
public int compareTo( Object o ) {
//--- If this fails, it'll throw a ClassCastException, which we
//--expect the idiot who pass us this argument to handle
SimilarityDescription arg = (SimilarityDescription) o;
int result = 0;
//--- default to being equal
if (this.getPercentSimilarity() < arg.getPercentSimilarity() ) {
result = 1;
}
if (this.getPercentSimilarity() > arg.getPercentSimilarity() ) {
result = -1;
}
}
return result;
//--- compareTo
//----------------------------------------------------------------------------// Accessors
//----------------------------------------------------------------------------/** Retun item
* @param Not param
* @return Item, case
* @exceptions Not Exceptions
*/
public Item getItem() {
return itemBeingDescribed;
}
/** Return Integer rank
* @param Not param
* @return Integer rank
* @exceptions Not Exceptions
*/
public int getRank() {
return rank;
}
/** Retun PercentSimilarity
* @param Not param
* @return Float Percent
* @exceptions Not Exceptions
*/
public float getPercentSimilarity() {
return percentMatch;
}
/** Set Item
* @param Item newItem, Item case
* @exceptions Not Exceptions
*/
protected void setItem( Item newItem ) {
itemBeingDescribed = newItem;
}
/** Set percent Similaruty
* @param float newPercentMatch, percent
* @exceptions Not Exceptions
194
Estudio para la implementación de un sistema de razonamiento basado en casos
*/
protected void setPercentSimilarity( float newPercentMatch ) {
percentMatch = newPercentMatch;
}
/** Set Rank
* @param int newRank, rank of item
* @exceptions Not Exceptions
*/
protected void setRank( int newRank ) {
rank = newRank;
}
}
//--- SimilarityDescription
*******************************************************************************************
SimilarityEngine.java
*******************************************************************************************
/**
This class is the most important in the proyect. It computes the similarity of a
collection
of items (cases) to a specified target case. The target case is specified by user and
user's
criterion search
The call to SimilarityEngine's main method, computeSimilarity(),takes the objects Items,
SimilarityCriteria and SimilarityWeights, that are needed for compute similarity
*/
package net.sourceforge.selectionengine;
import java.util.*;
/**
*
*
* @author <small>baylor</small>
*
*/
public class SimilarityEngine {
//----------------------------------------------------------------------------// Private Constants
//----------------------------------------------------------------------------private static final String MAX_VAL_INDICATOR = "[max_val]";
private static final String MIN_VAL_INDICATOR = "[min_val]";
//----------------------------------------------------------------------------// Methods
//----------------------------------------------------------------------------/** Get compute Distance between Target values and Item values
* @param SimilarityCriterionScores targetValues Values of target
* @param SimilarityCriterionScores itemValues Values of item
* @return Float Distance distance between they
* @exceptions Not Exceptions
*/
private float computeDistance( SimilarityCriterionScores targetValues,
SimilarityCriterionScores itemValues ) {
float sum = 0;
Iterator targetValueList = targetValues.iterator();
while (targetValueList.hasNext()) {
//--- This is the score for one of the several criteria
SimilarityCriterionScore targetScore =
(SimilarityCriterionScore) targetValueList.next();
SimilarityCriterionScore itemScore = itemValues.get(
targetScore.getID() );
float targetValue = targetScore.getWeightedValue();
float itemValue
= itemScore.getWeightedValue();
float delta = (targetValue - itemValue);
195
Estudio para la implementación de un sistema de razonamiento basado en casos
}
float squaredDelta = (delta * delta);
sum += squaredDelta;
//--- while targetValueList.hasNext
float distance = (float) Math.sqrt( sum );
}
return distance;
//--- computeDistance (from one item to target)
/** Get compute similarity
* @param Items items, collection of items
* @param SimilarityCriteria criteria, Criterion similarity
* @param SimilarityWeights weights, weighs
* @return SimilarItems collection
* @exceptions Not Exceptions
*/
public SimilarItems computeSimilarity( Items items,
SimilarityCriteria criteria,
SimilarityWeights weights ) {
//--- Calculate the DataSetStatistics on the items passed in
//--- If we are only being passed a subset of items
//--(ex. - the items have been filtered), the stats
//--will only be calculated on the subset of items
DataSetStatistics stats = new DataSetStatistics( items );
}
return computeSimilarity( items, criteria, weights, stats );
//--- computeSimilarity, all items, no passed-in data set stats
/** Get compute similarity
* @param Items items, collection of items
* @param SimilarityCriteria criteria, Criterion similarity
* @param SimilarityWeights weights, weighs
* @param DataSetStatistics statistics
* @return SimilarItems collection
* @exceptions Not Exceptions
*/
public SimilarItems computeSimilarity( Items items,
SimilarityCriteria criteria,
SimilarityWeights weights,
DataSetStatistics statistics ) {
//--- This is the item that we want to compare ourselves to
//--to see how similar we are
SimilarityCriterionScores targetValues =
getTargetValues( items.getTraitDescriptors(),
criteria, weights, statistics );
float maxDistance = getMaxDistance( criteria, weights );
//--- Create a similarity descriptor for each item
SimilarItems similarItems = new SimilarItems();
Iterator itemList = items.iterator();
while (itemList.hasNext()) {
Item item = (Item) itemList.next();
SimilarityDescription descriptor = new
SimilarityDescription();
descriptor.setItem( item );
SimilarityCriterionScores itemValues =
normalizeValues( item, criteria, weights,
statistics );
float distance = computeDistance( targetValues,
itemValues );
float percentDifference = (distance / maxDistance);
float percentSimilarity = (1 - percentDifference);
196
Estudio para la implementación de un sistema de razonamiento basado en casos
descriptor.setPercentSimilarity( percentSimilarity );
}
similarItems.add( descriptor );
//--- itemList.hasNext()
//--- Now that we know how similar everyone is, let's go and
//--and rank them so that the caller has an easy way to sort
//--the items and so to make it easier to select the
//--k-best matches
similarItems.rankItems();
}
//--- OK, we're all done, hand the whole package back to the caller
return similarItems;
//--- computeSimilarity (multiple items)
/**
* To compute how similar two items are, we first create
*
a single-dimensional range from 0 to some max distance
*
number. We then give each item a score that falls
*
somewhere in that range
* The perfect item will score 0, meaning the difference
*
between what we're looking for and this item is nothing
* The worst possible choice will score the max distance,
*
meaning it is the opposite of everything we wanted
* We can give every item a score without knowing the max distance,
*
but we need it if we want to compute percent similarity
* To get the max distance, figure out the number of criteria
*
we were measuring to compute similarity. Multiply each
*
by its weight. Square the weights, add them all together
*
and then take the square root of that. In other words,
*
do the old Pythagorean Theorem on the weights
* For those who don't remember 9th grade geometry (thank god!)
*
the Pythagorean Theorem is that, for right triangles,
*
the length of side c is (a^2 + b^2) = c^2,
*
so the length of c = sqrt(a^2 + b^2)
*/
private float getMaxDistance( SimilarityCriteria criteria,
SimilarityWeights weights ) {
float sum = 0;
//--- Square, sum, take square root
Iterator criteriaList = criteria.iterator();
while (criteriaList.hasNext()) {
SimilarityCriterion criterion = (SimilarityCriterion)
criteriaList.next();
String fieldName = criterion.getFieldName();
float weight = weights.get( fieldName );
weight *= weight;
in Java like ^?
}
//--- Isn't there a square operator
sum += weight;
//--- criteriaList.hasNext()
float squareOfSummedDeltas = (float) Math.sqrt( sum );
}
return squareOfSummedDeltas;
//--- getMaxDistance
/** Get values of the case target
* @param TraitDescriptors traitDescriptors, descriptors of attributes
* @param SimilarityCriteria criteria, Criterion similarity
* @param SimilarityWeights weights, weighs
* @param DataSetStatistics statistics
* @return SimilarityCriterionScores normalizedValues
* @exceptions Not Exceptions
*/
private SimilarityCriterionScores getTargetValues(
TraitDescriptors traitDescriptors,
SimilarityCriteria criteria,
SimilarityWeights weights,
DataSetStatistics statistics ) {
197
Estudio para la implementación de un sistema de razonamiento basado en casos
SimilarityCriterionScores normalizedValues = new
SimilarityCriterionScores();
//--- Compute the normalized and weighted values of each trait we're
//--measuring.
//--- The normalized value will be between 0 and 1
//--where 1 means you had the max value that existed in the data
set,
//--0 means you had the minimum value and any other number is
basically
//--how close you were to the min and max
Iterator criteriaList = criteria.iterator();
while (criteriaList.hasNext()) {
SimilarityCriterion criterion = (SimilarityCriterion)
criteriaList.next();
String criterionID
= criterion.getID();
String traitName
= criterion.getFieldName();
int
traitDataType = traitDescriptors.getDataType(
traitName );
SimilarityCriterionScore score
= new SimilarityCriterionScore( criterionID );
normalizedValues.add( score );
float position = 0;
if ( (traitDataType != TraitDescriptor.TYPE_FLOAT ) &&
(traitDataType != TraitDescriptor.TYPE_INTEGER) )
{
switch( criterion.getOperator() ) {
case
SimilarityCriterion.OPERATOR_SIMILAR:
position = 1;
break;
case
SimilarityCriterion.OPERATOR_NOT_SIMILAR:
position = 0;
break;
default:
}
position = 0;
break;
//--- switch operator
}
else
{
//--- We have numbers, so we want to
calculate where this
//--trait for this item falls on the
continuum
//--from min value to max value
//--- We also want it to normalized to a
Percentage
//--format, which means a float between
0 and 1
//--- Ex. - Say we have an SAT score of
1,000
//--The max score on the SAT is 1600,
min=400
//--Our 1000 is half way between 400 and
1600
//--We'd normalize this value to 0.5
(50%) by doing
//--(score - min) / range
//--= (1000 - 400) / (1600 - 400)
//--= 600 / 1200
//--= 0.5
TraitStatistics stats = statistics.get(
traitName );
float max
= stats.getMaximumValue();
float min
= stats.getMinimumValue();
float range = stats.getRange();
//--- Although numeric data in the data set
should always be numeric,
198
Estudio para la implementación de un sistema de razonamiento basado en casos
//--in the user's query, numeric data
can also be the special
//--String keywords [MAX_VAL] or
[MIN_VAL]
TraitValue traitValue = criterion.getValue(
);
float value = 0;
if (traitValue.toString().equals(
MAX_VAL_INDICATOR )) {
value = max;
} else if (traitValue.toString().equals(
MIN_VAL_INDICATOR )) {
value = min;
} else {
value = traitValue.toFloat();
}
}
//--- 0=min value, 1=max value, in between
means % of max
position = (value - min) / range;
//--- if dataType = ...
score.setNormalizedValue( position );
}
}
float weight
= weights.get( traitName );
float weightedValue = (position * weight);
score.setWeightedValue( weightedValue );
//--- criteriaList.hasNext()
return normalizedValues;
//--- getTargetValues
/** Nomralized values
* @param Item item,
* @param SimilarityCriteria criteria, Criterion similarity
* @param SimilarityWeights weights, weighs
* @param DataSetStatistics statistics
* @return SimilarityCriterionScores normalizedValues
* @exceptions Not Exceptions
*/
private SimilarityCriterionScores normalizeValues(
Item item,
SimilarityCriteria criteria,
SimilarityWeights weights,
DataSetStatistics statistics ) {
SimilarityCriterionScores normalizedValues = new
SimilarityCriterionScores();
//--- Compute the normalized and weighted values of each trait we're
//--measuring.
//--- The normalized value will be between 0 and 1
//--where 1 means you had the max value that existed in the data
set,
//--0 means you had the minimum value and any other number is
basically
//--how close you were to the min and max
Iterator criteriaList = criteria.iterator();
while (criteriaList.hasNext()) {
SimilarityCriterion criterion = (SimilarityCriterion)
criteriaList.next();
String traitName
= criterion.getFieldName();
int
traitDataType = item.getTraitDataType( traitName
);
String criterionID
= criterion.getID();
SimilarityCriterionScore score
= new SimilarityCriterionScore( criterionID );
normalizedValues.add( score );
float position = 0;
if ( (traitDataType != TraitDescriptor.TYPE_FLOAT ) &&
(traitDataType != TraitDescriptor.TYPE_INTEGER) ) {
//--- We have a string or boolean
199
Estudio para la implementación de un sistema de razonamiento basado en casos
//--- We only do "=" on those, so see if
they're equal
String value = item.getTraitValue( traitName
).toString();
String targetValue =
criterion.getValue().toString();
if (value.equals( targetValue )) {
position = 1;
} else {
position = 0;
}
} else {
//--- We have numbers, so we want to
calculate where this
//--trait for this item falls on the
continuum
//--from min value to max value
//--- We also want it to normalized to a
percentage
//--format, which means a float between
0 and 1
//--- Ex. - Say we have an SAT score of
1,000
//--The max score on the SAT is 1600,
min=400
//--Our 1000 is half way between 400 and
1600
//--We'd normalize this value to 0.5
(50%) by doing
//--(score - min) / range
//--= (1000 - 400) / (1600 - 400)
//--= 600 / 1200
//--= 0.5
float itemValue = item.getTraitValue(
traitName ).toFloat();
TraitStatistics stats = statistics.get(
traitName );
float min
= stats.getMinimumValue();
float range = stats.getRange();
}
position = (itemValue - min) / range;
//--- if dataType = ...
score.setNormalizedValue( position );
}
}
}
float weightedValue = (position * weights.get( traitName
));
score.setWeightedValue( weightedValue );
//--- criteriaList.hasNext()
return normalizedValues;
//--- normalizeValues
//--- SimilarityEngine
*******************************************************************************************
SimilarityWeigth.java
*******************************************************************************************
/**
This clas SimilarityWeight keep a one Attribute and your Weight
selected by User
This class has been modified to comment the methods
modified by Manuel Miguel Gimenez Arjona
*/
package net.sourceforge.selectionengine;
class SimilarityWeight
{
private String fieldName;
private Integer weight;
200
Estudio para la implementación de un sistema de razonamiento basado en casos
/** set Attribute and Weigth
* @param String Fieldname, name of attribute
* @param Integer Weight, weight of Attribute
* @exceptions Not Exceptions
*/
public SimilarityWeight( String fieldName, Integer weight )
{
this.fieldName = fieldName;
this.weight = weight;
}
/** Return Attribute
* @param String Attribute
* @exceptions Not Exceptions
*/
public String getFieldName()
{
return fieldName;
}
/** Return Weight
* @param not param
* @return integer weight
* @exceptions Not Exceptions
*/
public Integer getWeight()
{
return weight;
}
}
//--- SimilarityWeight
*******************************************************************************************
SimilarityWeigths.java
*******************************************************************************************
/**
This clas create a collection of Weights acordins Attributes search by
user and weights over Attributes
This class has been modified to comment the methods
modified by Manuel Miguel Gimenez Arjona
*/
package net.sourceforge.selectionengine;
import java.util.*;
/**
*
* @author <small>baylor</small>
*
*/
public class SimilarityWeights {
//----------------------------------------------------------------------------// Attributes
//----------------------------------------------------------------------------protected HashMap weights = new HashMap();
//----------------------------------------------------------------------------// Methods
//----------------------------------------------------------------------------/** Add HashMap Weights
* @param String fieldname, name of attribute
* @param int Weight, integer weight desire
* @exceptions Not Exceptions
*/
public void add( String fieldName, int weight ) {
//--- HashMaps require objects, no intrinsic data types
201
Estudio para la implementación de un sistema de razonamiento basado en casos
//--- So we gotta convert int to Integer to store it
Integer weightAsObject = new Integer( weight );
}
weights.put( fieldName, weightAsObject );
//--- add
/** Clone Object
* @param Not param
* @return Object hashMap
* @exceptions Not Exceptions
*/
public Object clone( ) {
SimilarityWeights newItems = new SimilarityWeights();
newItems.setValues( weights );
}
return (Object) newItems;
//--- clone
/** return Integer Value Weight from attribute
* @param String traitName
* @return integer value
* @exceptions Not Exceptions
*/
public int get( String traitName ) {
Integer value = (Integer) weights.get( traitName );
return value.intValue();
} //--- get
/** Return iterator
* @param Not param
* @return Iterator values
* @exceptions Not Exceptions
*/
public Iterator iterator() {
return weights.values().iterator();
} //--- iterator
/** Return Iterator
* @param Not param
* @return Iterator
* @exceptions Not Exceptions
*/
public Iterator mapIterator() {
return weights.entrySet().iterator();
} //--- iterator
/** setValues hashmap
* @param hashMap newVAlues
* @exceptions Not Exceptions
*/
private void setValues( HashMap newValues ) {
weights = (HashMap) newValues.clone();
} //--- setValues
/** return Size of Weights
* @param String name
* @exceptions Not Exceptions
*/
public int size() {
return weights.size();
} //--- size
}
//--- SimilarityWeights
*******************************************************************************************
Trait.java
*******************************************************************************************
/**
This class saves the attribute and its value, One case is composed by a group of
attribute - value pairs, This class saves a one pair at time.
202
Estudio para la implementación de un sistema de razonamiento basado en casos
This class has been modified to comment the methods
modified by Manuel Miguel Gimenez Arjona
*/
package net.sourceforge.selectionengine;
/**
*
* @author <small>baylor</small>
*
*/
public class Trait {
//--- Attributes
private String name = null;
private TraitValue value = null;
/**
Set Name attribute & value
* @param String name, name Attibute
* @param String value, value Attribute
* @exception Not Exceptions
*/
protected Trait( String name, String value ) {
setName( name );
setValue( value );
} //--- constructor
/**
Return Name of Attribute
* @param Not param
* @return String Name
* @exception Not Exceptions
*/
public String getName() {
return name;
}
/**
Return Value of Attribute
* @param Not param
* @return String value
* @exception Not Exceptions
*/
public TraitValue getValue() {
return value;
}
/**
Set Name attribute
* @param String name, name Attibute
* @exception Not Exceptions
*/
protected void setName( String newName ) {
this.name = newName;
} //--- setName
/**
Set value of attribute
* @param String newValue
* @exception Not Exceptions
*/
protected void setValue( String newValue ) {
this.value = new TraitValue( newValue );
} //--- setValue
}
//--- Trait
*******************************************************************************************
TraitDescriptor.java
203
Estudio para la implementación de un sistema de razonamiento basado en casos
*******************************************************************************************
/**
This class saves the name of the attribute, the datatype of atribute.
It has been modified for accept visible attributes
*/
package net.sourceforge.selectionengine;
import java.util.*;
import java.io.*;
public class TraitDescriptor implements Serializable {
//--- Public constants
public static final int TYPE_UNKNOWN = 0;
public static final int TYPE_BOOLEAN = 1;
public static final int TYPE_FLOAT
= 2;
public static final int TYPE_INTEGER = 3;
public static final int TYPE_STRING = 4;
//----------------------------------------------------------------------------//--- Private constants
private static final String
private static final String
private static final String
private static final String
BOOLEAN_ABBREVIATION
FLOAT_ABBREVIATION
INTEGER_ABBREVIATION
STRING_ABBREVIATION
=
=
=
=
"b";
"f";
"i";
"s";
//----------------------------------------------------------------------------//--- Attributes
private String name = null;
private boolean included = false;
private int dataType = TYPE_UNKNOWN;
//----------------------------------------------------------------------------/**
Construct traitDescriptor
* @param String name, name of attribute
* @param String Type, TypeData
* @param boolean included, true or false is visible?
* @exception Not Exceptions
*/
TraitDescriptor( String name, String type, boolean included ) {
//added by Ivan Lopez-Arevalo
//this method receive two parameters para crear un TraitDescriptor
//the name (String) and the type of data (according to the constants)
//In theory it must receive only the above constants types
try {
this.name
= name;
this.included = included;
this.dataType = obtainDataType( type );
} catch (Exception e) {
String methodName = "TraitDescriptor::TraitDescriptor( Vector dataVector )";
System.out.println( methodName + " error: " + e );
}
} //--- constructor
//----------------------------------------------------------------------------// Methods
//----------------------------------------------------------------------------/**
Return DataType
* @param Not Param
* @return int datatype
* @exception Not Exceptions
*/
public int getDataType() {
return dataType;
}
204
Estudio para la implementación de un sistema de razonamiento basado en casos
/**
Return Name Attribute
* @param Not Param
* @return String name
* @exception Not Exceptions
*/
public String getName() {
return name;
}
/**
Return is visible?
* @param Not Param
* @return boolean Included, true or false is visible?
* @exception Not Exceptions
*/
public boolean getIncluded() {
return included;
}
/**
Return Numeric value
* @param String dataType
* @return int datatype
* @exception Not Exceptions
*/
private int stringToDataType( String dataType ) {
int numericValue = TYPE_UNKNOWN;
if (dataType.equals( BOOLEAN_ABBREVIATION )) {
numericValue = TYPE_BOOLEAN;
} else
if (dataType.equals( FLOAT_ABBREVIATION )) {
numericValue = TYPE_FLOAT;
} else
if (dataType.equals( INTEGER_ABBREVIATION )) {
numericValue = TYPE_INTEGER;
} else
if (dataType.equals( STRING_ABBREVIATION )) {
numericValue = TYPE_STRING;
}
//--- figure out the datatype
}
return numericValue;
//--- stringToDataType
/**
Return Numeric value
* @param String dataType
* @return int datatype
* @exception Not Exceptions
*/
private int obtainDataType( String dataType ) {
int numericValue = TYPE_UNKNOWN;
if ( dataType.equals("Boolean") ){
numericValue = TYPE_BOOLEAN;
} else
if ( dataType.equals("Float") ){
numericValue = TYPE_FLOAT;
} else
if ( dataType.equals("Integer") ){
numericValue = TYPE_INTEGER;
} else
if ( dataType.equals("String") ){
numericValue = TYPE_STRING;
}
}
//--- figure out the datatype
return numericValue;
//--- stringToDataType
public String toString( ) {
205
Estudio para la implementación de un sistema de razonamiento basado en casos
return getName();
}
}
//--- TraitDescriptor
*******************************************************************************************
TraitDescriptors.java
*******************************************************************************************
/**
This class saves a collection of TraitDescriptor objects.
A TraitDescritor object saves the name of attribute, its datatype and the
visible attribute
This class has been modified to comment the methods
modified by Manuel Miguel Gimenez Arjona
*/
package net.sourceforge.selectionengine;
import cbr.*;
import java.util.*;
public class TraitDescriptors{
//--- Should probably have the trait and trait descriptors
//--act the same for get's and iterator
ArrayList traitDescriptors = new ArrayList();
/**
add traitDescriptor to collection
* @param int index, index in collection
* @param TraitDescriptor descriptor, Descriptors of item
* @exception Not Exceptions
*/
private void add( int index, TraitDescriptor descriptor ) {
traitDescriptors.add( index, descriptor );
} //--- add
/**
is empty collection?
* @param not params
* @return boolean isEmpty
* @exception Not Exceptions
*/
public boolean isEmpty() {
return traitDescriptors.isEmpty();
}
/*
return Iterator
* @param not params
* @return Iterator collection
* @exception Not Exceptions
*/
public Iterator iterator() {
//--- Returns an iterator to an array list containing
//--TraitDescriptor objects
return traitDescriptors.iterator();
} //--- iterator
/*
return TraitDescriptor
* @param int Index, index of traitdescriptor
* @return traitDescriptor
* @exception Not Exceptions
*/
206
Estudio para la implementación de un sistema de razonamiento basado en casos
public TraitDescriptor get( int index ) {
return (TraitDescriptor) traitDescriptors.get( index );
} //--- get
/*
return TraitDescriptor
* @param String traitName, name of attribute
* @return traitDescriptor
* @exception Not Exceptions
*/
public TraitDescriptor get( String traitName ) {
TraitDescriptor matchingDescriptor = null;
Iterator cursor = traitDescriptors.iterator();
while (cursor.hasNext()) {
TraitDescriptor traitDescriptor = (TraitDescriptor)
cursor.next();
//System.out.println (traitDescriptor.getName() +" "+traitName);
if (traitDescriptor.getName().equals( traitName )) {
matchingDescriptor = traitDescriptor;
}
} //--- hasNext
}
return matchingDescriptor;
//--- getTraitDescriptor
/*
return integer Datatype
* @param String traitName, name of attribute
* @return int Datatype
* @exception Not Exceptions
*/
public int getDataType( String traitName ) {
TraitDescriptor traitDescriptor = get( traitName );
}
return traitDescriptor.getDataType();
//--- getDataType
/*
loadTraitDescriptorOfCase, keep traitdescriptors case
* @param ArrayList listMeta, list of cases
* @exception Error Exceptions
*/
protected void loadTraitDescriptorOfCase(ArrayList listMeta) {
//added by Manuel Miguel Gimenez Arjona
//this method create the TraitDescriptor collection from the properties of a Unit
object
int entryNumber = 0;
TraitDescriptor traitDescriptor;
MetaInfoImpl metaInfoNew;
try {
Iterator it = listMeta.iterator();
while (it.hasNext()) {
metaInfoNew = (MetaInfoImpl)it.next();
//
if (metaInfoNew.included() == true){
traitDescriptor = new TraitDescriptor(
metaInfoNew.name_attribute(),
metaInfoNew.typeName_attribute(),
metaInfoNew.included());
this.add( entryNumber, traitDescriptor ); entryNumber++;
//
}
}
207
Estudio para la implementación de un sistema de razonamiento basado en casos
} catch (Exception e) {
System.out.println( "Error into TraitDescriptors::loadTraitDescriptor()" + "
error: " + e );
}
}
/*
return integer size collection
* @param not param
* @return int size collection
* @exception Not Exceptions
*/
public int size() {
return traitDescriptors.size();
} //--- size
}
//--- TraitDescriptors
*******************************************************************************************
TraitPanel.java
*******************************************************************************************
/*
This class has been modified to comment the methods- Manuel Miguel Gimenez Arjona
*/
package cbr;
import java.util.*;
import javax.swing.JPanel;
import javax.swing.*;
import net.sourceforge.selectionengine.TraitDescriptor; //--- trait data types
/**
* Title:
TraitPanel
* Description: JPanel doesn't have an ActionCommand or Tag or any place
*
to store info. To be able to dynamically create
*
a UI for the PCShoppingAssistant application, i want to be
*
able to ask a panel what trait it represents. i'd also like
*
to know the button groups in it so i can extract values.
*
And knowing the data type of the trait it represents would
*
be pretty useful
* Copyright:
Copyright (c) 2001
* Company:
University of St Thomas
* @author baylor wetzel
* @version 1.0
*/
public class TraitPanel extends JPanel {
//--------------------------------------------------------------------------//--- Attributes
//--------------------------------------------------------------------------protected JCheckBox filterCheckBox = null;
protected JComboBox filterOperatorComboBox = null;
protected JComboBox filterValueComboBox = null;
protected JComboBox preferenceValueComboBox = null;
protected JCheckBox similarityCheckBox = null;
protected int traitDataType = TraitDescriptor.TYPE_UNKNOWN;
protected String traitName = "";
protected ButtonGroup valueButtonGroup = null;
protected ButtonGroup weightButtonGroup = null;
//--------------------------------------------------------------------------//--- Constructors
//--------------------------------------------------------------------------//--------------------------------------------------------------------------//--- Public Methods
208
Estudio para la implementación de un sistema de razonamiento basado en casos
//--------------------------------------------------------------------------/** Return filterCheckBox
* @param Not params
* @return JCheckBox filterCheckBox
* @exception Not Exceptions
*/
public JCheckBox getFilterCheckBox() {
return filterCheckBox;
}
/** set filterCheckBox asign JCheckBox
* @param JCheckBox filterCheckBox
* @exception Not Exceptions
*/
public void setFilterCheckBox(JCheckBox filterCheckBox) {
this.filterCheckBox = filterCheckBox;
}
/** Return JCheckBox of Similarity
* @param Not params
* @return JCheckBox similarityCheckBox
* @exception Not Exceptions
*/
public JCheckBox getSimilarityCheckBox() {
return similarityCheckBox;
}
/** Set Similarity CheckBox
* @param JCheckBox preferCheckBox
* @exception Not Exceptions
*/
public void setSimilarityCheckBox(JCheckBox preferCheckBox) {
this.similarityCheckBox = preferCheckBox;
}
/** Return name Attribute
* @param Not params
* @return String traitName name of attribute
* @exception Not Exceptions
*/
public String getTraitName() {
return traitName;
}
/** Set traitName os attribute
* @param String name name of attribute
* @exception Not Exceptions
*/
public void setTraitName(String name) {
this.traitName = name;
}
/** get Datatype of attribute
* @param Not params
* @return int traitDataType, type of attribute
* @exception Not Exceptions
*/
public int getTraitDataType() {
return traitDataType;
}
/** set TraitDataType
* @param int Datatype
* @exception Not Exceptions
*/
public void setTraitDataType(int dataType) {
this.traitDataType = dataType;
}
/** get JcomboBox
* @param Not params
* @return JComboBox filterOperatorComboBox
* @exception Not Exceptions
*/
public JComboBox getFilterOperatorComboBox() {
209
Estudio para la implementación de un sistema de razonamiento basado en casos
return filterOperatorComboBox;
}
/** set FilterOperatorComboBox
* @param JComboBox list
* @exception Not Exceptions
*/
public void setFilterOperatorComboBox(JComboBox list) {
filterOperatorComboBox = list;
}
/** get FilterOperator
* @param Not params
* @return String value value operator
* @exception Exceptions printStackTrace()
*/
public String getFilterOperator() {
String value = null;
try {
switch (traitDataType) {
case TraitDescriptor.TYPE_INTEGER:
case TraitDescriptor.TYPE_FLOAT:
case TraitDescriptor.TYPE_STRING:
JComboBox list = getFilterOperatorComboBox();
value = list.getSelectedItem().toString();
break;
case TraitDescriptor.TYPE_BOOLEAN:
value = "=";
//--- Always
break;
}
}
catch (Exception e) {
e.printStackTrace();
}
}
return value;
//--- getFilterOperator
/** return String Valuefilter
* @param Not params
* @return String value value filter conbobox
* @exception Exceptions printStackTrace()
*/
public String getFilterValue() {
String value = null;
try {
JComboBox list = getFilterValueComboBox();
value = list.getSelectedItem().toString();
}
catch (Exception e) {
e.printStackTrace();
}
}
return value;
//--- getFilterValue
/** getFilterValueComboBox
* @param Not params
* @return JComboBox filterValueComboBox
* @exception Not Exceptions
*/
public JComboBox getFilterValueComboBox() {
return filterValueComboBox;
}
/** getFilterValueComboBox
* @param JComboBox list, list value
* @exception Not Exceptions
*/
public void setFilterValueComboBox(JComboBox list) {
filterValueComboBox = list;
210
Estudio para la implementación de un sistema de razonamiento basado en casos
}
/** getPreferenceValue
* @param Not params
* @return String value, value prefer
* @exception Exceptions printStackTrace()
*/
public String getPreferenceValue() {
String value = null;
try {
JComboBox list = getPreferenceValueComboBox();
value = list.getSelectedItem().toString();
}
catch (Exception e) {
e.printStackTrace();
}
return value;
}
//--- Only applies if the trait is numeric, not strings or booleans
/** getValueButtonGroup
* @param Not params
* @return ButtonGroup valueButtonGroup
* @exception Not exceptions
*/
public ButtonGroup getValueButtonGroup() {
return valueButtonGroup;
}
/** setValueButtonGroup
* @param ButtonGroup group
* @exception Not Exceptions
*/
public void setValueButtonGroup(ButtonGroup group) {
valueButtonGroup = group;
}
//--- Only applies if the trait is string or boolean
/** getPreferenceValueComboBox
* @param Not params
* @return JComboBox preferenceValueComboBox
* @exception Not exceptions
*/
public JComboBox getPreferenceValueComboBox() {
return preferenceValueComboBox;
}
/** setPreferenceValueComboBox
* @param JComboBox list
* @exception Not Exceptions
*/
public void setPreferenceValueComboBox(JComboBox list) {
this.preferenceValueComboBox = list;
}
/** getWeightButtonGroup
* @param Not params
* @return ButtonGroup weightButtonGroup
* @exception Not exceptions
*/
public ButtonGroup getWeightButtonGroup() {
return weightButtonGroup;
}
/** setWeightButtonGroup
* @param ButtonGroup group
* @exception Not exceptions
*/
public void setWeightButtonGroup(ButtonGroup group) {
weightButtonGroup = group;
}
211
Estudio para la implementación de un sistema de razonamiento basado en casos
/** getWeight
* @param Not params
* @return Int weight
* @exception exceptions traitpanel
*/
public int getWeight() {
int weight = 0;
try {
ButtonGroup radioButtons = getWeightButtonGroup();
String actionCommand = radioButtons.getSelection().getActionCommand().trim();
weight = Integer.parseInt(actionCommand);
}
catch (Exception e) {
//--- If we have a problem, return a weight of 0
//--- A 0 weight is like not having this criteria at all
System.out.println("TraitPanel::getWeight: " + e);
}
return weight;
}
/** return hasFilterCriteria
* @param Not params
* @return boolean hasFilterCriteria
* @exception exceptions filterCheckBox for TraitPanel not set
*/
public boolean hasFilterCriteria() {
boolean hasFilterCriteria = false;
try {
JCheckBox checkBox = getFilterCheckBox();
hasFilterCriteria = checkBox.isSelected();
}
catch (Exception e) {
System.out.println("Exception: filterCheckBox for TraitPanel not set");
}
}
return hasFilterCriteria;
//--- hasFilterCriteria
/** return hasSimilarityCriteria
* @param Not params
* @return boolean hasSimilarityCriteria
* @exception exceptions similarityCheckBox for TraitPanel not set
*/
public boolean hasSimilarityCriteria() {
boolean hasSimilarityCriteria = false;
try {
JCheckBox checkBox = getSimilarityCheckBox();
hasSimilarityCriteria = checkBox.isSelected();
}
catch (Exception e) {
System.out.println("Exception: similarityCheckBox for TraitPanel not set");
}
}
return hasSimilarityCriteria;
//--- hasSimilarityCriteria
//--------------------------------------------------------------------------//--- Protected Methods
//--------------------------------------------------------------------------}
//--- TraitPanel
*******************************************************************************************
TraitStatistics.java
*******************************************************************************************
/*
212
Estudio para la implementación de un sistema de razonamiento basado en casos
This class has been modified to comment the methods
modified by Manuel Miguel Gimenez Arjona
*/
package net.sourceforge.selectionengine;
/**
* The TraitStatistics class contains statistical info
*
about the various values for a single, specific trait.
*
That includes the max value, min value and range
*
* This class has two primary purposes.
* First, we need this info to handle queries that use the variables
*
[MAX_VALUE] and [MIN_VALUE]
* Second, we need the min, max and range info to do the
*
nearest neighbor/similarity calculation
*
* Although this should be obvious, this class was only designed
*
to work with numbers - i don't want to compute degrees of
*
similarity on strings or booleans
* When building stats for strings and booleans, min=0 max=1
*
* It is believed that DataSetStatistics is the only class
*
that will instantiate this one. The class was designed
*
to be contained by DataSetStatistics
*
* @author <small>baylor</small>
*
*/
public class TraitStatistics {
//----------------------------------------------------------------------------// Attributes
//----------------------------------------------------------------------------private String traitName;
private float minimumValue;
private float maximumValue;
private int
numberOfExamples = 0;
//----------------------------------------------------------------------------// Constructors
//----------------------------------------------------------------------------public TraitStatistics( String traitName ) {
setTraitName( traitName );
}
//----------------------------------------------------------------------------// Methods
//----------------------------------------------------------------------------/** Put minimum value and maximun value
* @param Float value
* @exceptions Not Exceptions
*/
public void addExample( float value ) {
if (numberOfExamples == 0) {
this.setMinimumValue( value );
this.setMaximumValue( value );
} else {
if (value < getMinimumValue()) {
this.setMinimumValue( value );
}
if (value > getMaximumValue()) {
this.setMaximumValue( value );
}
}
}
numberOfExamples++;
//--- addExample
/** return Maximun value
* @param Not Param
* @return float maximum value
213
Estudio para la implementación de un sistema de razonamiento basado en casos
* @exceptions Not Exceptions
*/
public float getMaximumValue() {
return maximumValue;
} //--- getMaximumValue
/** return minimum
* @param Not Param
* @return int , value integer
* @exceptions Not Exceptions
*/
public float getMinimumValue() {
return minimumValue;
} //--- getMinimumValue
/** return name trait
* @param Not Param
* @return String traitname, name of attribute
* @exceptions Not Exceptions
*/
public String getTraitName() {
return traitName;
} //--- getTraitName
/** return get range (maxvalue - minvalue)
* @param Not Param
* @return float range
* @exceptions Not Exceptions
*/
public float getRange() {
return (maximumValue - minimumValue);
} //--- getMinimumValue
/** set max value
* @param float value, value max
* @exceptions Not Exceptions
*/
protected void setMaximumValue( float value ) {
maximumValue = value;
} //--- setMaximumValue
/** set min value
* @param float value
* @exceptions Not Exceptions
*/
protected void setMinimumValue( float value ) {
minimumValue = value;
} //--- setMinimumValue
/** set traitname
* @param String name
* @exceptions Not Exceptions
*/
protected void setTraitName( String name ) {
traitName = name;
} //--- setTraitName
}
//--- TraitStatistics
*******************************************************************************************
TraitValue.java
*******************************************************************************************
/**
This class converts the value of attribute in its datatype format
and return it
This class has been modified to comment the methods
modified by Manuel Miguel Gimenez Arjona
*/
package net.sourceforge.selectionengine;
public class TraitValue
214
Estudio para la implementación de un sistema de razonamiento basado en casos
{
//----------------------------------------------------------------------------// Attributes
//----------------------------------------------------------------------------private String value;
//----------------------------------------------------------------------------// Constructors
//----------------------------------------------------------------------------public TraitValue( String value )
{
this.value = value;
}
//----------------------------------------------------------------------------// Methods
//----------------------------------------------------------------------------/** return integer value
* @param Not Param
* @return int , value integer
* @exceptions Not Exceptions
*/
public int toInteger ()
{
Integer integerValue = new Integer( value );
return integerValue.intValue();
} //--- toInteger
/** return Boolean value
* @param Not Param
* @return boolean , value boolean
* @exceptions Not Exceptions
*/
public boolean toBoolean ()
{
Boolean booleanValue = new Boolean( value );
return booleanValue.booleanValue();
} //--- toBoolean
/** return Float value
* @param Not Param
* @return float , value float
* @exceptions Not Exceptions
*/
public float toFloat ()
{
Float floatValue = new Float( value );
return floatValue.floatValue();
} //--- toFloat
/** return String value
* @param Not Param
* @return String , value String
* @exceptions Not Exceptions
*/
public String toString ()
{
return value;
} //--- toString
/** return String value
* @param Not Param
* @return String , value String
* @exceptions Not Exceptions
*/
public String value ()
{
return toString();
}
215
Estudio para la implementación de un sistema de razonamiento basado en casos
}
//--- TraitValue
*******************************************************************************************
Traits.java
*******************************************************************************************
/**
This class containt a collection of Trait objects, each Trait object is a pair
of attribute - value
This class has been modified to comment the methods
modified by Manuel Miguel Gimenez Arjona
*/
package net.sourceforge.selectionengine;
import java.util.*;
/**
* @author baylor
* modified by Manuel Miguel Gimenez Arjona
*/
public class Traits {
//----------------------------------------------------------------------------// Attributes
//----------------------------------------------------------------------------private HashMap traits = new HashMap();
//----------------------------------------------------------------------------// Methods
//----------------------------------------------------------------------------/**
* Insert objects Trait in hasMap for rapid accesvkey for insert is name Attribute
* @param trait newTrait, trait for insert
* @exception Not Exceptions
*/
protected void add( Trait newTrait ) {
String key = newTrait.getName();
traits.put( key, newTrait );
}
/** return object trait
* @param String traitname, Name of attribute
* @return trait
* @exception Not Exceptions
*/
public Trait get( String traitName ) {
return (Trait) traits.get( traitName );
} //--- get
/** Return boolean if Traits is Empty
* @param not params
* @return boolean is empty
* @exception Not Exceptions
*/
public boolean isEmpty() {
return traits.isEmpty();
}
/** Return iterator of values Traits
* @param Not params
* @return Iterator
* @exception Not Exceptions
*/
public Iterator iterator() {
return traits.values().iterator();
}
/**
216
Estudio para la implementación de un sistema de razonamiento basado en casos
* Load data from a string
* The string will have the data fields in the same
*
order as the array of field definitions
* The string is | delimited
*/
protected void loadFromDelimitedCase( TraitDescriptors traitDescriptors,
ArrayList caseItem ) {
try {
int fieldNumber = 0;
Iterator it = caseItem.iterator();
while (it.hasNext()) {
String key = traitDescriptors.get(fieldNumber).toString();
String value = (String)it.next();
Trait trait = new Trait( key, value );
add( trait );
fieldNumber++;
}
}
}
//--- while hasNext
} //--- try
catch (Exception e) {
e.printStackTrace();
} //--- catch
//--- loadFromDelimitedCase
//--- Traits
*******************************************************************************************
WindowCaseDelete.java
*******************************************************************************************
/**
This class displays a case to delete, show all attributes and values of a case
and confirm the deletion from casebase
Programmer: Manuel Miguel Gimenez Arjona
Proyect:CBR Extraccion Module
Directors: Ivan Lopez Arevalo / Aïda Valls Mateu
Departament de Enginyeria Informatica i Matematiques
Universitat Rovira i Virgili
Date: 2.08.2005
*/
package cbr;
import
import
import
import
import
import
import
import
import
import
java.io.*;
java.awt.*;
java.util.*;
javax.swing.*;
java.awt.event.*;
java.awt.print.*;
java.text.DecimalFormat;
java.awt.print.PrinterJob;
net.sourceforge.selectionengine.*;
javax.swing.table.AbstractTableModel;
import javax.swing.table.DefaultTableCellRenderer;
import javax.swing.table.TableCellRenderer;
import javax.swing.table.TableColumn;
public class WindowCaseDelete extends JPanel{
//var
public static final int TYPE_FLOAT
= 2;
public static final int TYPE_INTEGER = 3;
JEditorPane resultsEditorPane = new JEditorPane();
217
Estudio para la implementación de un sistema de razonamiento basado en casos
ArrayList list;
ArrayList listMeta;
JFrame frame;
int position;
Hashtable casesAcces;
String code;
CasesImpl caseObtain;
/** WindowCaseDelete
* @param JFrame frameOriginal, frame main window
* @param ArrayList listMeta, List of metaCases
* @param HashTable casesAcces, hashTable for immediate acces
* @param ArrayList list, list of cases
* @param String code, Code of case for immendiate acces
* @param CasesImpl caseObtain, case for delete
* @param RepositoryOzone ozoneRepository, OzoneRepository for delete
* @exception Exception error results
*/
public WindowCaseDelete(JFrame frameOriginal, ArrayList listMeta, Hashtable casesAcces,
ArrayList list, String code, CasesImpl caseObtain, final RepositoryOzone ozoneRepository)
{//throws Exception
try{
//var
frame = frameOriginal;
Container contentPaneDialog;
JPanel resultsPanel = new JPanel();
JPanel buttonPanel = new JPanel();
JButton cancelButton = new JButton();
JButton printButton = new JButton();
JButton deleteButton = new JButton();
final JTable tableResults;
JScrollPane scrollPane;
this.list = list;
this.listMeta = listMeta;
this.caseObtain = caseObtain;
this.casesAcces = casesAcces;
this.code = code;
final Vector data;
// image
JPanel titlePanel = new JPanel();
ImageIcon imagen= new ImageIcon ("images/DibujoDeleteCase.jpg");
JLabel labelTitle = new JLabel(imagen);
resultsPanel.setLayout(new BorderLayout());
resultsPanel.setBorder(BorderFactory.createEmptyBorder(20,20,20,20));
final JDialog dialog = new JDialog(frame);
dialog.setTitle("Are you sure delete Case?");
// class for generate information case delete
displayDeleteNew dispResult = new displayDeleteNew(frame, listMeta, list,
caseObtain);
tableResults = new JTable(dispResult);
data = dispResult.getData();
tableResults.setBackground(Color.lightGray);
scrollPane = new JScrollPane(tableResults);
resultsPanel.add(scrollPane, BorderLayout.CENTER);
//butons
cancelButton.setText("Cancel");
cancelButton.setBounds(100,20,100,20);
cancelButton.addActionListener(new java.awt.event.ActionListener(){
public void actionPerformed(ActionEvent e){
dialog.dispose();
}
});
deleteButton.setText("Delete Case");
deleteButton.setBounds(100,20,100,20);
deleteButton.addActionListener(new java.awt.event.ActionListener(){
public void actionPerformed(ActionEvent e) {
deleteButton_actionPerformed(e, ozoneRepository, dialog);
}
});
buttonPanel.add(cancelButton, null);
buttonPanel.setLayout(new FlowLayout());
buttonPanel.add(cancelButton);
buttonPanel.add(deleteButton, null);
218
Estudio para la implementación de un sistema de razonamiento basado en casos
buttonPanel.add(deleteButton);
//dialog inserts
dialog.getContentPane().add(labelTitle,BorderLayout.NORTH);
dialog.getContentPane().add(resultsPanel, BorderLayout.CENTER);
dialog.getContentPane().add(buttonPanel,BorderLayout.SOUTH);
dialog.setSize(new Dimension(500, 465)); // 500 - 300
dialog.setLocationRelativeTo(frame);
dialog.setResizable(false);
dialog.setVisible(true);
}catch (Exception excep) {
JOptionPane.showMessageDialog( frame, "Error" + excep,
"Information",
JOptionPane.INFORMATION_MESSAGE );
}
}
/** Action boton Delete case, delete case from database
* @param ActionEvent e
* @param RepositoryOzone ozoneRepository, ozone repository
* @param JDialog dialog, dialog of window
* @exception not Exception
*/
public void deleteButton_actionPerformed( ActionEvent e, RepositoryOzone
ozoneRepository, JDialog dialog) {
if (JOptionPane.showConfirmDialog(frame,"Are you sure delete case?",
"Delete
case",JOptionPane.YES_NO_OPTION)
==
JOptionPane.YES_OPTION){
dialog.dispose();
int index = list.indexOf(caseObtain);
list.remove(list.indexOf(caseObtain)); // remove of list Cases
casesAcces.remove(code);
// remove of hash
ozoneRepository.deleteCase(index);
// remove of database ozone
JOptionPane.showMessageDialog( frame, "Delete Case Succesful",
"Information",
JOptionPane.INFORMATION_MESSAGE );
}
}
//***************************************************************************
//***************************************************************************
/**
Class DisplayDeletenew,for create a abstractTableModel of case delete
Programmer: Manuel Miguel Gimenez Arjona
Proyect:CBR Extraccion Module
Directors: Ivan Lopez Arevalo / Aïda Valls Mateu
Departament de Enginyeria Informatica i Matematiques
Universitat Rovira i Virgili
Date: 2.08.2005
*/
class displayDeleteNew extends AbstractTableModel{
private Vector columnNames = new Vector(1,1);
private Vector data = new Vector(1,1); //rows
private int counter = 0;
private String traitName, value;
Vector columns;
private JFrame frame;
CasesImpl caseDelete;
ArrayList listMeta;
219
Estudio para la implementación de un sistema de razonamiento basado en casos
/** DisplayEditNew, show attributes of delete case
* @param JFrame jframe, jframe
* @param ArrayList listMeta, List of metaCases
* @param ArrayList listCases, list of cases
* @param CasesImpl caseObtain, case for delete
* @exception Not Exception
*/
public displayDeleteNew( JFrame frameX, ArrayList listMeta, ArrayList listCases,
CasesImpl caseObtain){// p/Sustances
//var
int i, j, counter;
this.frame = frameX;
this.listMeta = listMeta;
MetaInfoImpl metaInf;
//column Names
columnNames.add("ATTRIBUTE");
columnNames.add("VALUE");
columns = new Vector(1,1);
ArrayList attributesCase = caseObtain.list();
for (i=0; i < listMeta.size(); i++ ) { // all attributes of listMeta
metaInf = (MetaInfoImpl) listMeta.get(i);
traitName = metaInf.name_attribute(); // name of Attribute
columns = new Vector(1,1);
columns.add(traitName.toUpperCase());
columns.add((String)attributesCase.get(i));
data.add(columns); // Attribut and Value
}
}//constructor
/** get colum size
* @param Not params
* @return return int, Vector size
* @exception Not Exception
*/
public int getColumnCount() {
return columnNames.size();
}
/** get data size
* @param Not params
* @return return int, data size
* @exception Not Exception
*/
public int getRowCount() {
return data.size();
}
/** get Data
* @param not params
* @return return Vector, Vector data
* @exception Not Exception
*/
public Vector getData() {
return data;
}
/** get column Name
* @param int col, index of column
* @return return String, name of column
* @exception Not Exception
*/
220
Estudio para la implementación de un sistema de razonamiento basado en casos
public String getColumnName(int col) {
return (String)columnNames.elementAt(col);
}
/** get value
* @param int row, index of row
* @param int col, index of column
* @return return object, object that contain position
* @exception Not Exception
*/
public Object getValueAt(int row, int col) {
return ((Vector)data.elementAt(row)).elementAt(col);
}
/** Class column
* @param int c, integer row
* @return return Class, Class of position object
* @exception Not Exception
*/
public Class getColumnClass(int c) {
return getValueAt(0, c).getClass();
}
/** is editable?
* @param int row, integer row
* @param int col, integer column
* @return return boolean, false is editable
* @exception Not Exception
*/
public boolean isCellEditable(int row, int col) {
return false;
}
}
}
*******************************************************************************************
WindowCaseEdit.java
*******************************************************************************************
/**
Class for edit cases of the casebase
Programmer: Manuel Miguel Gimenez Arjona
Proyect:CBR Extraccion Module
Directors Proyect: Ivan Lopez Arevalo / Aïda Valls Mateu
University: Universitat Rovira i Virgili
Date: 2.08.2005
*/
package cbr;
import
import
import
import
import
import
import
import
import
import
java.io.*;
java.awt.*;
java.util.*;
javax.swing.*;
java.awt.event.*;
java.awt.print.*;
java.text.DecimalFormat;
java.awt.print.PrinterJob;
net.sourceforge.selectionengine.*;
javax.swing.table.AbstractTableModel;
221
Estudio para la implementación de un sistema de razonamiento basado en casos
import javax.swing.table.DefaultTableCellRenderer;
import javax.swing.table.TableCellRenderer;
import javax.swing.table.TableColumn;
public class WindowCaseEdit extends JPanel{
//Var
JEditorPane resultsEditorPane = new JEditorPane();
ArrayList listCases;
JFrame frame;
ArrayList listMeta;
Hashtable casesAcces;
CasesImpl caseObtain;
String code;
/** WindowCaseEdit
@param JFrame frameOriginal, JFrame main window
* @param ArrayList listMeta, List of metaCases
* @param HashTable casesAcces, hashTable for immediate acces
* @param ArrayList list, list of cases
* @param String code, Code of case for immendiate acces
* @param CasesImpl caseObtain, case for delete
* @param RepositoryOzone ozoneRepository, ozone repository
* @exception Exception error results
*/
public WindowCaseEdit(JFrame frameOriginal, ArrayList listMeta, Hashtable casesAcces,
ArrayList listCases, String code, CasesImpl caseObtain, final RepositoryOzone
ozoneRepository) {//throws Exception
try{
// var
frame = frameOriginal;
Container contentPaneDialog;
JPanel resultsPanel = new JPanel();
JPanel buttonPanel = new JPanel();
JButton cancelButton = new JButton();
JButton printButton = new JButton();
JButton saveButton = new JButton();
final JTable tableResults;
JScrollPane scrollPane;
this.listCases = listCases;
this.listMeta = listMeta;
this.casesAcces = casesAcces;
this.caseObtain = caseObtain;
this.code = code;
final Vector data;
//image
JPanel titlePanel = new JPanel();
ImageIcon imagen= new ImageIcon ("images/DibujoEditCase.jpg");
JLabel labelTitle = new JLabel(imagen);
resultsPanel.setLayout(new BorderLayout());
resultsPanel.setBorder(BorderFactory.createEmptyBorder(20,20,20,20));
final JDialog dialog = new JDialog(frame);
//title
dialog.setTitle("Case Edit");
displayInfoEdit dispResult = new displayInfoEdit(frame, listMeta,
this.listCases, caseObtain);
tableResults = new JTable(dispResult);
data = dispResult.getData();
tableResults.setBackground(Color.lightGray);
scrollPane = new JScrollPane(tableResults);
resultsPanel.add(scrollPane, BorderLayout.CENTER);
//butons
cancelButton.setText("Cancel");
cancelButton.setBounds(100,20,100,20);
cancelButton.addActionListener(new java.awt.event.ActionListener(){
public void actionPerformed(ActionEvent e){
dialog.dispose();
}
});
222
Estudio para la implementación de un sistema de razonamiento basado en casos
saveButton.setText("Save Case");
saveButton.setBounds(100,20,100,20);
saveButton.addActionListener(new java.awt.event.ActionListener(){
public void actionPerformed(ActionEvent e) {
SaveButton_actionPerformed(e, data, ozoneRepository, dialog);
buttonPanel.add(cancelButton, null);
buttonPanel.setLayout(new FlowLayout());
buttonPanel.add(cancelButton);
buttonPanel.add(saveButton, null);
buttonPanel.add(saveButton);
}
});
//dialog inserts
dialog.getContentPane().add(labelTitle,BorderLayout.NORTH);
dialog.getContentPane().add(resultsPanel, BorderLayout.CENTER);
dialog.getContentPane().add(buttonPanel,BorderLayout.SOUTH);
dialog.setSize(new Dimension(500, 465)); // 500 - 300
dialog.setLocationRelativeTo(frame);
dialog.setResizable(false);
dialog.setVisible(true);
}catch (Exception excep) {
JOptionPane.showMessageDialog( frame, "Error:" + excep,
"Error", JOptionPane.ERROR_MESSAGE );
}
}
/** Action boton Save case
* @param ActionEvent e
* @param Vector Data, Data of case
* @param RepositoryOzone ozoneRepository, ozone repository
* @param JDialog dialog, dialog of window
* @exception not Exception
*/
public void SaveButton_actionPerformed( ActionEvent e, Vector data,RepositoryOzone
ozoneRepository, JDialog dialog ) {
//var
CasesImpl cases;
Iterator it = data.iterator();
ArrayList casesTemp = new ArrayList();
int entryNumber = 0;
ArrayList listTemp = new ArrayList();
String attribute;
int i = 0;
boolean error = false;
String reference = "null";
while (it.hasNext() & !error) { // while exist attributes
Vector infoCaseVector = (Vector)it.next();
if (infoCaseVector.get(1).equals("")){ // if camp value es blank
error = true;
}
else{
casesTemp.add(entryNumber,infoCaseVector.get(1));
entryNumber++;
}
}
if (!error){ // if not exist null
cases = new CasesImpl();
cases.setList(casesTemp);
int position = listCases.indexOf(caseObtain); // obtain position
listCases.remove(position);
// remove list of cases
listCases.add(position,cases);
// insert list of cases
casesAcces.remove(code);
// remove hash
casesAcces.put(code, cases );
// edit hash
ozoneRepository.EditCase(position,cases); // edit ozone database
dialog.dispose();
JOptionPane.showMessageDialog( frame, "Edit Case Succesful",
"Information",
JOptionPane.INFORMATION_MESSAGE );
223
Estudio para la implementación de un sistema de razonamiento basado en casos
}else{
JOptionPane.showMessageDialog( frame, "Error in
Parameters: Value is null",
"Error", JOptionPane.ERROR_MESSAGE );
}
}
//***************************************************************************
//***************************************************************************
/**
Class DisplayInfoEdit, for create a abstractTableModel of case
Programmer: Manuel Miguel Gimenez Arjona
Proyect:CBR Extraccion Module
Directors Proyect: Ivan Lopez Arevalo / Aïda Valls Mateu
University: Universitat Rovira i Virgili
Date: 2.08.2005
*/
class displayInfoEdit extends AbstractTableModel{
//var
private Vector columnNames = new Vector(1,1);
private Vector data = new Vector(1,1); //rows
private String HTML = new String("");
private String traitName, value;
Vector columns;
private JFrame frame;
CasesImpl caseEdit;
ArrayList listMeta;
/** DisplayInfoEdit, show attributes of edit case
* @param JFrame jframe, jframe
* @param ArrayList listMeta, List of metaCases
* @param ArrayList listCases, list of cases
* @param CasesImpl caseObtain, case for edit
* @exception Not Exception
*/
public displayInfoEdit( JFrame frameX, ArrayList listMeta, ArrayList listCases,
CasesImpl caseObtain ){// p/Sustances
String results = "null";;
int i, j, counter;
this.frame = frameX;
MetaInfoImpl metaInf;
this.listMeta = listMeta;
columnNames.add("ATTRIBUTE");
columnNames.add("VALUE");
columnNames.add("DATA TYPE");
columns = new Vector(1,1);
ArrayList attributesCase = caseObtain.list();
for (i=0; i < listMeta.size(); i++ ) {
metaInf = (MetaInfoImpl) listMeta.get(i);
traitName = metaInf.name_attribute(); // attribute
columns = new Vector(1,1);
columns.add(traitName.toUpperCase());
columns.add((String)attributesCase.get(i));
// insert type of attribute in table model
224
Estudio para la implementación de un sistema de razonamiento basado en casos
if ( metaInf.typeName_attribute().equals("Boolean")) {
columns.add("[ Data Type BOOLEAN ]");
}else if ( metaInf.typeName_attribute().equals("Float") ) {
columns.add("[ Data Type FLOAT ]");
}else if ( metaInf.typeName_attribute().equals("Integer") ) {
columns.add("[ Data Type INTEGER ]");
}else{
columns.add("[ Data Type STRING ]");
}
data.add(columns);
}
}//constructor
/** get colum size
* @param Not params
* @return return int, Vector size
* @exception Not Exception
*/
public int getColumnCount() {
return columnNames.size();
}
/** get data size
* @param Not params
* @return return int, data size
* @exception Not Exception
*/
public int getRowCount() {
return data.size();
}
/** get Data
* @param not params
* @return return Vector, Vector data
* @exception Not Exception
*/
public Vector getData() {
return data;
}
/** get column Name
* @param int col, index of column
* @return return String, name of column
* @exception Not Exception
*/
public String getColumnName(int col) {
return (String)columnNames.elementAt(col);
}
/** get value
* @param int row, index of row
* @param int col, index of column
* @return return object, object that contain position
* @exception Not Exception
*/
public Object getValueAt(int row, int col) {
return ((Vector)data.elementAt(row)).elementAt(col);
}
/** Class column
* @param int c, integer row
* @return return Class, Class of position object
* @exception Not Exception
*/
225
Estudio para la implementación de un sistema de razonamiento basado en casos
public Class getColumnClass(int c) {
return getValueAt(0, c).getClass();
}
/** is editable?
* @param int row, integer row
* @param int col, integer column
* @return return boolean, true or false is editable
* @exception Not Exception
*/
public boolean isCellEditable(int row, int col) {
if (col == 1) {
if (row == 0){
return false;
}else{
return true;
}
} else {
return false;
}
}
/** Set value at table
* @param object Value, new value
* @param int row, integer row
* @param int col, integer column
* @exception Not Exception
*/
public void setValueAt(Object value, int row, int col) {
Vector column = (Vector)data.get(row);
String dataType = (String)column.get(2);
MetaInfoImpl metaInf = (MetaInfoImpl)this.listMeta.get(row);
if (metaInf.typeName_attribute().equals("Boolean")){ // is boolean?
String tempValue = (String)value;
tempValue = tempValue.toLowerCase();
if (!tempValue.equals("false") && !tempValue.equals("true")){
JOptionPane.showMessageDialog( null, "Data type Parameters: Require
Boolean - true or false",
"Error", JOptionPane.ERROR_MESSAGE );
column.add(1,"");
}else{
column.add(1,tempValue);
}
}else if (metaInf.typeName_attribute().equals("Float")){
//is float?
try{
float var = Float.parseFloat((String)value);
String varConvert = String.valueOf(var);
column.add(1,varConvert);
} catch (NumberFormatException e2) {
JOptionPane.showMessageDialog( null, "Data type
Parameters: Require Integer",
"Error", JOptionPane.ERROR_MESSAGE );
column.add(1,"");
}
}else if (metaInf.typeName_attribute().equals("Integer")){ // is integer??
try{
int var = Integer.parseInt((String)value);
column.add(1,value);
} catch (NumberFormatException e2) {
JOptionPane.showMessageDialog( null, "Data type
Parameters: Require Integer",
226
Estudio para la implementación de un sistema de razonamiento basado en casos
"Error", JOptionPane.ERROR_MESSAGE );
column.add(1,"");
}
}else{
column.add(1,value);
}
column.add(2,dataType);
}
}
}
*******************************************************************************************
WindowCaseNew.java
*******************************************************************************************
/**
Class for insert values to attributes of a empty case
Programmer: Manuel Miguel Gimenez Arjona
Proyect:CBR Extraccion Module
Directors Proyect: Ivan Lopez Arevalo / Aïda Valls Mateu
University: Universitat Rovira i Virgili
Date: 2.08.2005
*/
package cbr;
import
import
import
import
import
import
import
import
import
import
java.io.*;
java.awt.*;
java.util.*;
javax.swing.*;
java.awt.event.*;
java.awt.print.*;
java.text.DecimalFormat;
java.awt.print.PrinterJob;
net.sourceforge.selectionengine.*;
javax.swing.table.AbstractTableModel;
import javax.swing.table.DefaultTableCellRenderer;
import javax.swing.table.TableCellRenderer;
import javax.swing.table.TableColumn;
public class WindowCaseNew extends JPanel{
//var
JEditorPane resultsEditorPane = new JEditorPane();
ArrayList listCases;
JFrame frame;
Hashtable casesAcces;
ArrayList listMeta;
/** WindowCaseNew
* @param JFrame frameOriginal, JFrame main window
* @param ArrayList listMeta, List of metaCases
* @param HashTable casesAcces, hashTable for immediate acces
* @param ArrayList list, list of cases
* @param RepositoryOzone ozoneRepository, Repository Ozone
* @exception Exception error results
*/
public WindowCaseNew(JFrame frameOriginal,ArrayList listMeta, Hashtable casesAcces,
ArrayList listCases, final RepositoryOzone ozoneRepository) {//throws Exception
try{
//var
frame = frameOriginal;
Container contentPaneDialog;
JPanel resultsPanel = new JPanel();
227
Estudio para la implementación de un sistema de razonamiento basado en casos
JPanel buttonPanel = new JPanel();
JButton cancelButton = new JButton();
JButton printButton = new JButton();
JButton saveButton = new JButton();
final JTable tableResults;
JScrollPane scrollPane;
this.listCases = listCases;
this.casesAcces = casesAcces;
final Vector data;
// image
JPanel titlePanel = new JPanel();
ImageIcon imagen= new ImageIcon ("images/DibujoNewCase.jpg");
JLabel labelTitle = new JLabel(imagen);
//this.traitDescriptors = traitDescriptors;
this.listMeta = listMeta;
resultsPanel.setLayout(new BorderLayout());
resultsPanel.setBorder(BorderFactory.createEmptyBorder(20,20,20,20));
final JDialog dialog = new JDialog(frame);
//title
dialog.setTitle("New Case");
displayInfoNew dispResult = new displayInfoNew(frame, this.listMeta,
this.listCases);
tableResults = new JTable(dispResult);
data = dispResult.getData();
tableResults.setBackground(Color.lightGray);
scrollPane = new JScrollPane(tableResults);
resultsPanel.add(scrollPane, BorderLayout.CENTER);
//butons
cancelButton.setText("Cancel");
cancelButton.setBounds(100,20,100,20);
cancelButton.addActionListener(new java.awt.event.ActionListener(){
public void actionPerformed(ActionEvent e){
dialog.dispose();
}
});
saveButton.setText("Save Case");
saveButton.setBounds(100,20,100,20);
saveButton.addActionListener(new java.awt.event.ActionListener(){
public void actionPerformed(ActionEvent e) {
SaveButton_actionPerformed(e, data, ozoneRepository, dialog);
});
buttonPanel.add(cancelButton, null);
buttonPanel.setLayout(new FlowLayout());
buttonPanel.add(cancelButton);
buttonPanel.add(saveButton, null);
buttonPanel.add(saveButton);
}
dialog.getContentPane().add(labelTitle,BorderLayout.NORTH);
dialog.getContentPane().add(resultsPanel, BorderLayout.CENTER);
dialog.getContentPane().add(buttonPanel,BorderLayout.SOUTH);
dialog.setSize(new Dimension(500, 465));
dialog.setLocationRelativeTo(frame);
dialog.setResizable(false);
dialog.setVisible(true);
}catch (Exception excep) {
JOptionPane.showMessageDialog( frame, "Error:" + excep,
"Error", JOptionPane.ERROR_MESSAGE );
}
}
/** Action boton Save case
* @param ActionEvent e
* @param Vector Data, Data of case
* @param RepositoryOzone ozoneRepository, Ozone repository
* @exception not Exception
*/
228
Estudio para la implementación de un sistema de razonamiento basado en casos
public void SaveButton_actionPerformed( ActionEvent e, Vector data, RepositoryOzone
ozoneRepository, JDialog dialog ) {
CasesImpl cases;
Iterator it = data.iterator();
ArrayList casesTemp = new ArrayList();
int entryNumber = 0;
ArrayList listTemp = new ArrayList();
String attribute;
int i = 0;
boolean error = false;
String reference = "null";
while (it.hasNext() & !error) { // while exist attributes
Vector infoCaseVector = (Vector)it.next();
if (infoCaseVector.get(1).equals("")){ // if Attribute is empty
error = true;
}
else{
if(infoCaseVector.get(0).equals("REFERENCE")){
reference = (String)infoCaseVector.get(1);
}
casesTemp.add(entryNumber,infoCaseVector.get(1));
entryNumber++;
}
}
if (!error){ // if not exist null
cases = new CasesImpl();
cases.setList(casesTemp);
this.listCases.add(this.listCases.size(),cases); // put new case in list of
cases
casesAcces.put(reference, cases );
// put new case in hash
ozoneRepository.saveCaseObtain(cases); // save case in ozone database
dialog.dispose();
JOptionPane.showMessageDialog( frame, "Insert Case Succesful",
"Information",
JOptionPane.INFORMATION_MESSAGE );
}else{
JOptionPane.showMessageDialog( frame, "Error in
Parameters: Value is null",
"Error", JOptionPane.ERROR_MESSAGE );
}
}
//***************************************************************************
//***************************************************************************
/**
Internal class for insert values to the attributes of an empty case
Programmer: Manuel Miguel Gimenez Arjona
Proyect:CBR Extraccion Module
Directors: Ivan Lopez Arevalo / Aïda Valls Mateu
Departament de Enginyeria Informatica i Matematiques
Universitat Rovira i Virgili
Date: 2.08.2005
*/
class displayInfoNew extends AbstractTableModel{
private Vector columnNames = new Vector(1,1);
private Vector data = new Vector(1,1); //rows
private String traitName, value;
Vector columns;
ArrayList listMeta;
229
Estudio para la implementación de un sistema de razonamiento basado en casos
private JFrame frame;
CasesImpl cases;
/** DisplayInfoNew, show attributes cases
* @param JFrame frameX, jframe
* @param ArrayList listMeta, List of metaCases
* @param ArrayList listCases, list of cases
* @exception Not Exception
*/
public displayInfoNew( JFrame frameX, ArrayList listMeta, ArrayList listCases ){//
p/Sustances
int i, j, counter;
this.frame = frameX;
this.listMeta = listMeta;
ArrayList listTemp = new ArrayList();
MetaInfoImpl metaInf;
// colum Names
columnNames.add("ATTRIBUTE");
columnNames.add("VALUE");
columnNames.add("DATA TYPE");
columns = new Vector(1,1);
for (i=0; i < listMeta.size(); i++ ) { // for all attributes of case
metaInf = (MetaInfoImpl) listMeta.get(i);
traitName = metaInf.name_attribute();
columns = new Vector(1,1);
columns.add(traitName.toUpperCase());
if ( i == 0 ){ // create refenrence
cases = new CasesImpl();
if(listCases.size() == 0){ // case reference Initial
columns.add("cbr-0001000");
}else{
// create refenrece for others cases
cases = (CasesImpl)listCases.get(listCases.size()1); // reference of last case
listTemp = cases.list();
String reference = (String)listTemp.get(0);
reference = reference.substring(4);
int var = Integer.parseInt(reference);
var = var + 1; // incremet reference
String varConvert = String.valueOf(var);
reference = "cbr-000" + varConvert;
columns.add(reference);
}
}else{
columns.add("");
}
// insert type of attributes
if ( metaInf.typeName_attribute().equals("Boolean")) {
columns.add("[ Data Type BOOLEAN ]");
}else if ( metaInf.typeName_attribute().equals("Float") ) {
columns.add("[ Data Type FLOAT ]");
}else if ( metaInf.typeName_attribute().equals("Integer") ) {
columns.add("[ Data Type INTEGER ]");
}else{
columns.add("[ Data Type STRING ]");
}
data.add(columns);
}
230
Estudio para la implementación de un sistema de razonamiento basado en casos
}//constructor
/** get colum size
* @param Not params
* @return return int, Vector size
* @exception Not Exception
*/
public int getColumnCount() {
return columnNames.size();
}
/** get data size
* @param Not params
* @return return int, data size
* @exception Not Exception
*/
public int getRowCount() {
return data.size();
}
/** get Data
* @param not params
* @return return Vector, Vector data
* @exception Not Exception
*/
public Vector getData() {
return data;
}
/** get column Name
* @param int col, index of column
* @return return String, name of column
* @exception Not Exception
*/
public String getColumnName(int col) {
return (String)columnNames.elementAt(col);
}
/** get value
* @param int row, index of row
* @param int col, index of column
* @return return object, object that contain position
* @exception Not Exception
*/
public Object getValueAt(int row, int col) {
return ((Vector)data.elementAt(row)).elementAt(col);
}
/** Class column
* @param int c, integer row
* @return return Class, Class of position object
* @exception Not Exception
*/
public Class getColumnClass(int c) {
return getValueAt(0, c).getClass();
}
/** is editable?
* @param int row, integer row
* @param int col, integer column
* @return return boolean, true or false is editable
* @exception Not Exception
*/
public boolean isCellEditable(int row, int col) {
if (col == 1) {
if (row == 0){
231
Estudio para la implementación de un sistema de razonamiento basado en casos
return false;
}else{
return true;
}
} else {
return false;
}
}
/** Set value at table
* @param object Value, new value
* @param int row, integer row
* @param int col, integer column
* @exception Not Exception
*/
public void setValueAt(Object value, int row, int col) {
Vector column = (Vector)data.get(row);
String dataType = (String)column.get(2);
MetaInfoImpl metaInf = (MetaInfoImpl)this.listMeta.get(row);
if (metaInf.typeName_attribute().equals("Boolean")){
String tempValue = (String)value;
tempValue = tempValue.toLowerCase();
if (!tempValue.equals("false") && !tempValue.equals("true")){
JOptionPane.showMessageDialog( null, "Data type Parameters: Require
Boolean - true or false",
"Error", JOptionPane.ERROR_MESSAGE );
column.add(1,"");
}else{
column.add(1,tempValue);
}
}else if (metaInf.typeName_attribute().equals("Float")){
try{
float var = Float.parseFloat((String)value);
String varConvert = String.valueOf(var);
column.add(1,varConvert);
} catch (NumberFormatException e2) {
JOptionPane.showMessageDialog( null, "Data type
Parameters: Require Integer",
"Error", JOptionPane.ERROR_MESSAGE );
column.add(1,"");
}
}else if (metaInf.typeName_attribute().equals("Integer")){
try{
int var = Integer.parseInt((String)value);
column.add(1,value);
} catch (NumberFormatException e2) {
JOptionPane.showMessageDialog( null, "Data type
Parameters: Require Integer",
"Error", JOptionPane.ERROR_MESSAGE );
column.add(1,"");
}
}else{
column.add(1,value);
}
column.add(2,dataType);
}
}
}
232
Estudio para la implementación de un sistema de razonamiento basado en casos
*******************************************************************************************
WindowCaseView.java
*******************************************************************************************
/**
Class for display all the cases in the casebase
Programmer: Manuel Miguel Gimenez Arjona
Proyect:CBR Extraccion Module
Directors: Ivan Lopez Arevalo / Aïda Valls Mateu
Departament de Enginyeria Informatica i Matematiques
Universitat Rovira i Virgili
Date: 2.08.2005
*/
package cbr;
import
import
import
import
import
import
import
import
import
import
java.io.*;
java.awt.*;
java.util.*;
javax.swing.*;
java.awt.event.*;
java.awt.print.*;
java.text.DecimalFormat;
java.awt.print.PrinterJob;
net.sourceforge.selectionengine.*;
javax.swing.table.AbstractTableModel;
import javax.swing.table.DefaultTableCellRenderer;
import javax.swing.table.TableCellRenderer;
import javax.swing.table.TableColumn;
public class WindowCaseView extends JPanel{
//var
JEditorPane resultsEditorPane = new JEditorPane();
ArrayList list;
ArrayList listMeta;
int position;
Hashtable casesAcces;
String code;
/** WindowCaseView
* @param JFrame frameOriginal, frame main window
* @param ArrayList listMeta, List of metaCases
* @param ArrayList list, list of cases
* @exception Exception error results
*/
public WindowCaseView(JFrame frameOriginal, ArrayList listMeta, ArrayList list)
{//throws Exception
try{
//var
final JFrame frame = frameOriginal;
Container contentPaneDialog;
JPanel resultsPanel = new JPanel();
JPanel buttonPanel = new JPanel();
JButton okButton = new JButton();
JButton printButton = new JButton();
final JTable tableResults;
JScrollPane scrollPane;
this.list = list;
this.listMeta = listMeta;
this.position = position;
this.casesAcces = casesAcces;
this.code = code;
final Vector data;
//image
233
Estudio para la implementación de un sistema de razonamiento basado en casos
JPanel titlePanel = new JPanel();
ImageIcon imagen= new ImageIcon ("images/DibujoNewAllCases.jpg");
JLabel labelTitle = new JLabel(imagen);
resultsPanel.setLayout(new BorderLayout());
resultsPanel.setBorder(BorderFactory.createEmptyBorder(20,20,20,20));
final JDialog dialog = new JDialog(frame);
// title
dialog.setTitle("View All cases of DataBase");
displayViewNew dispResult = new displayViewNew(frame, listMeta, list);
tableResults = new JTable(dispResult);
data = dispResult.getData();
tableResults.setBackground(Color.lightGray);
scrollPane = new JScrollPane(tableResults);
resultsPanel.add(scrollPane, BorderLayout.CENTER);
// butons
okButton.setText("ok");
okButton.setBounds(100,20,100,20);
okButton.addActionListener(new java.awt.event.ActionListener(){
public void actionPerformed(ActionEvent e){
dialog.dispose();
}
});
buttonPanel.add(okButton, null);
buttonPanel.setLayout(new FlowLayout());
buttonPanel.add(okButton);
//dialog inserts
dialog.getContentPane().add(labelTitle,BorderLayout.NORTH);
dialog.getContentPane().add(resultsPanel, BorderLayout.CENTER);
dialog.getContentPane().add(buttonPanel,BorderLayout.SOUTH);
dialog.setSize(new Dimension(980, 465)); // 500 - 300
dialog.setLocationRelativeTo(frame);
dialog.setResizable(false);
dialog.setVisible(true);
}catch (Exception excep) {
JOptionPane.showMessageDialog( null, "Error:" + excep,
"Error", JOptionPane.ERROR_MESSAGE );
}
}
//***************************************************************************
//***************************************************************************
/**
Class DisplayViewNew,for create a abstractTableModel of all Attributes of all cases
Programmer: Manuel Miguel Gimenez Arjona
Proyect:CBR Extraccion Module
Directors: Ivan Lopez Arevalo / Aïda Valls Mateu
Departament de Enginyeria Informatica i Matematiques
Universitat Rovira i Virgili
Date: 2.08.2005
*/
class displayViewNew extends AbstractTableModel{
private Vector columnNames = new Vector(1,1);
private Vector data = new Vector(1,1); //rows
private String traitName, value;
Vector columns;
private JFrame frame;
CasesImpl caseView;
ArrayList listTemp;
String attribute;
234
Estudio para la implementación de un sistema de razonamiento basado en casos
/** DisplayViewNew, show all cases
* @param JFrame frameX, frame main window
* @param ArrayList listMeta, List of metaCases
* @param ArrayList listCases, list of cases
* @exception Not Exception
*/
public displayViewNew( JFrame frameX, ArrayList listMeta, ArrayList listCases){//
p/Sustances
String results = "null";;
int i, j, counter;
this.frame = frameX;
MetaInfoImpl metaInf;
for (i=0; i < listMeta.size(); i++ ) { // all attributes
metaInf = (MetaInfoImpl) listMeta.get(i);
traitName = metaInf.name_attribute();
columnNames.add(traitName);
}
Iterator itCases = listCases.iterator();
while (itCases.hasNext()) { // all cases
caseView = (CasesImpl)itCases.next();
listTemp = caseView.list();
Iterator it = listTemp.iterator();
Vector columns = new Vector(1,1);
while (it.hasNext()) {
attribute = (String)it.next();
columns.add(attribute);
}
data.add(columns);
}
}//constructor
/** get colum size
* @param Not params
* @return return int, Vector size
* @exception Not Exception
*/
public int getColumnCount() {
return columnNames.size();
}
/** get data size
* @param Not params
* @return return int, data size
* @exception Not Exception
*/
public int getRowCount() {
return data.size();
}
/** get Data
235
Estudio para la implementación de un sistema de razonamiento basado en casos
* @param not params
* @return return Vector, Vector data
* @exception Not Exception
*/
public Vector getData() {
return data;
}
/** get column Name
* @param int col, index of column
* @return return String, name of column
* @exception Not Exception
*/
public String getColumnName(int col) {
return (String)columnNames.elementAt(col);
}
/** get value
* @param int row, index of row
* @param int col, index of column
* @return return object, object that contain position
* @exception Not Exception
*/
public Object getValueAt(int row, int col) {
return ((Vector)data.elementAt(row)).elementAt(col);
}
/** Class column
* @param int c, integer row
* @return return Class, Class of position object
* @exception Not Exception
*/
public Class getColumnClass(int c) {
return getValueAt(0, c).getClass();
}
/** is editable?
* @param int row, integer row
* @param int col, integer column
* @return return boolean, true or false is editable
* @exception Not Exception
*/
public boolean isCellEditable(int row, int col) {
return false;
}
}
}
//--- ResultsWindow
*******************************************************************************************
WindowCasesInfo.java
*******************************************************************************************
/**
Class for display all the attributes of a case
Programmer: Manuel Miguel Gimenez Arjona
236
Estudio para la implementación de un sistema de razonamiento basado en casos
Proyect:CBR Extraccion Module
Directors: Ivan Lopez Arevalo / Aïda Valls Mateu
Departament de Enginyeria Informatica i Matematiques
Universitat Rovira i Virgili
Date: 2.08.2005
*/
package cbr;
import
import
import
import
import
import
import
import
import
import
java.io.*;
java.awt.*;
java.util.*;
javax.swing.*;
java.awt.event.*;
java.awt.print.*;
java.text.DecimalFormat;
java.awt.print.PrinterJob;
net.sourceforge.selectionengine.*;
javax.swing.table.AbstractTableModel;
import javax.swing.table.DefaultTableCellRenderer;
import javax.swing.table.TableCellRenderer;
import javax.swing.table.TableColumn;
public class WindowCasesInfo extends JPanel{
JEditorPane resultsEditorPane = new JEditorPane();
String results = "null";
/** WindowCasesInfo
* @param int rank, intteger rank of case
* @param SimilarItems similarItems, contain similar cases
* @param TraitDescriptors traitDescriptors, traitDescriptors of cases
* @exception Exception error results
*/
public WindowCasesInfo(int rank, SimilarItems similarItems, TraitDescriptors
traitDescriptors) {//throws Exception
try{
//Var
final JFrame frame = new JFrame();
Container contentPaneDialog;
JPanel resultsPanel = new JPanel();
JPanel buttonPanel = new JPanel();
JButton okButton = new JButton();
JButton cancelButton = new JButton();
JButton printButton = new JButton();
JButton saveButton = new JButton();
final JTable tableResults;
JScrollPane scrollPane;
//image
JPanel titlePanel = new JPanel();
ImageIcon imagen= new ImageIcon ("images/DibujoCase.jpg");
JLabel labelTitle = new JLabel(imagen);
final JDialog dialog = new JDialog(frame);
resultsPanel.setLayout(new BorderLayout());
resultsPanel.setBorder(BorderFactory.createEmptyBorder(20,20,20,20));
//Title
dialog.setTitle("Case-based Reasoning Module - Results");
displayResultsInfo dispResult = new displayResultsInfo(frame, rank,
similarItems, traitDescriptors);
tableResults = new JTable(dispResult); // results
tableResults.setBackground(Color.lightGray);
scrollPane = new JScrollPane(tableResults);
resultsPanel.add(scrollPane, BorderLayout.CENTER);
//buttons
237
Estudio para la implementación de un sistema de razonamiento basado en casos
okButton.setText("Ok");
okButton.setBounds(100,20,100,20);
okButton.addActionListener(new java.awt.event.ActionListener(){
public void actionPerformed(ActionEvent e){
dialog.dispose();
}
});
buttonPanel.add(okButton, null);
buttonPanel.setLayout(new FlowLayout());
buttonPanel.add(okButton);
//dilog inserts
dialog.getContentPane().add(labelTitle,BorderLayout.NORTH);
dialog.getContentPane().add(resultsPanel, BorderLayout.CENTER);
dialog.getContentPane().add(buttonPanel,BorderLayout.SOUTH);
dialog.setSize(new Dimension(380, 465)); // 500 - 300
dialog.setLocationRelativeTo(frame);
dialog.setResizable(false);
dialog.setVisible(true);
}catch (Exception excep) {
JOptionPane.showMessageDialog( null, "Error:" + excep,
"Error", JOptionPane.ERROR_MESSAGE );
}
}
//***************************************************************************
//***************************************************************************
/**
Class DisplayResultsInfo,for create a abstractTableModel of all Attributes of case
Programmer: Manuel Miguel Gimenez Arjona
Proyect:CBR Extraccion Module
Directors: Ivan Lopez Arevalo / Aïda Valls Mateu
Departament de Enginyeria Informatica i Matematiques
Universitat Rovira i Virgili
Date: 2.08.2005
*/
class displayResultsInfo extends AbstractTableModel{
//var
private Vector columnNames = new Vector(1,1);
private Vector data = new Vector(1,1); //rows
private TraitDescriptor traitDescriptor;
private SimilarityDescription similarityDescription;
private int percentSimilarity, rank;
private String traitName, value;
private Iterator cursor;
private Item item;
Vector columns;
private JFrame frame;
/** DisplayResultsInfo, show attributes cases
* @param JFrame framex, main frame
* @param int rank, integer rank
* @param SimilarItems items, similar items
* @param TraitDescriptors traitDescriptors, traitDestriptors of cases
* @exception Not Exception
*/
public displayResultsInfo( JFrame frameX, int rank, SimilarItems items,
TraitDescriptors traitDescriptors ){// p/Sustances
int i, j, counter, descriptorSize = traitDescriptors.size();
this.frame = frameX;
// Column names
columnNames.add("ATTRIBUTE");
columnNames.add("VALUE");
238
Estudio para la implementación de un sistema de razonamiento basado en casos
columns = new Vector(1,1);
cursor = items.getByRank(rank + 1).iterator();
similarityDescription = (SimilarityDescription) cursor.next();
percentSimilarity = (int) (100 * similarityDescription.getPercentSimilarity());
// similarity
item = similarityDescription.getItem();
// Attributes Special
columns.add( "RANK" );
columns.add( String.valueOf(rank + 1) );
data.add(columns);
columns = new Vector(1,1);
columns.add( "SIMILARITY" );
columns.add( percentSimilarity + " %" );
data.add(columns);
for (i=0; i < descriptorSize; i++ ) { // for All Attributes of Items
traitDescriptor = traitDescriptors.get( i );
traitName = traitDescriptor.getName(); // name Attribute
value = item.getTraitValue( traitName ).value();
columns = new Vector(1,1);
columns.add(traitName.toUpperCase());
columns.add(value);
data.add(columns);
}
}//constructor
/** get colum size
* @param Not params
* @return return int, Vector size
* @exception Not Exception
*/
public int getColumnCount() {
return columnNames.size();
}
/** get data size
* @param Not params
* @return return int, data size
* @exception Not Exception
*/
public int getRowCount() {
return data.size();
}
/** get column Name
* @param int col, index of column
* @return return String, name of column
* @exception Not Exception
*/
public String getColumnName(int col) {
return (String)columnNames.elementAt(col);
}
/** get value
* @param int row, index of row
* @param int col, index of column
* @return return object, object that contain position
* @exception Not Exception
*/
public Object getValueAt(int row, int col) {
return ((Vector)data.elementAt(row)).elementAt(col);
}
239
Estudio para la implementación de un sistema de razonamiento basado en casos
/** Class column
* @param int c, integer row
* @return return Class, Class of position object
* @exception Not Exception
*/
public Class getColumnClass(int c) {
return getValueAt(0, c).getClass();
}
/** is editable?
* @param int row, integer row
* @param int col, integer column
* @return return boolean, true or false is editable
* @exception Not Exception
*/
public boolean isCellEditable(int row, int col) {
return false;
}
}
}
*******************************************************************************************
WindowMetaDataCase.java
*******************************************************************************************
/**
Class for create metadata cases
Programmer: Manuel Miguel Gimenez Arjona
Proyect:CBR Extraccion Module
Directors: Ivan Lopez Arevalo / Aïda Valls Mateu
Departament de Enginyeria Informatica i Matematiques
Universitat Rovira i Virgili
Date: 2.08.2005
*/
package cbr;
import
import
import
import
import
import
import
import
import
import
java.io.*;
java.awt.*;
java.util.*;
javax.swing.*;
java.awt.event.*;
java.awt.print.*;
java.text.DecimalFormat;
java.awt.print.PrinterJob;
net.sourceforge.selectionengine.*;
javax.swing.table.AbstractTableModel;
import javax.swing.table.DefaultTableCellRenderer;
import javax.swing.table.TableCellRenderer;
import javax.swing.table.TableColumn;
public class WindowMetaDataCase extends JPanel{
//var
JEditorPane resultsEditorPane = new JEditorPane();
ArrayList list;
JFrame frame;
240
Estudio para la implementación de un sistema de razonamiento basado en casos
int position;
Hashtable casesAcces;
String code;
int index = 0;
JPanel resultsPanel = new JPanel();
JPanel insertpanel = new JPanel();
JPanel deletePanel = new JPanel();
Vector columns;
JScrollPane scrollPane;
JTable tableResults;
JComboBox comboBox;
JComboBox comboBoxVisible;
JTextField fieldAttribute;
JTextField fielDelete;
displayMetaDataCaseNew dispResult;
ArrayList listMeta = new ArrayList ();
//JMenuItem
JMenuItem newFind;
JMenuItem viewList;
JMenuItem insertCase;
JMenuItem editCase;
JMenuItem deleteCase;
JMenuItem metaDataOpCase;
JMenuItem maxCasesView;
int numAttributes = 0;
/** WindowMetadataCase, Create window for insert metadata
* @param JFrame frameOriginal, frame main Window
* @param ArrayList listMeta, list of metacases
* @param ArrayList list, list of cases
* @param JMenuItem newFind, set true or false if create metadata
* @param JMenuItem viewList, set true or false if create metadata
* @param JMenuItem insertCase, set true or false if create metadata
* @param JMenuItem editCase. set true or false if create metadata
* @param JMenuItem deleteCase, set true or false if create metadata
* @param JMenuItem metaDataOpCase,set true or false if create metadata
* @param JMenuItem maxCasesView, set true or false if create metadata
* @exception Exception error results
*/
public WindowMetaDataCase(JFrame frameOriginal, final ArrayList listMeta, final
ArrayList list, JMenuItem newFind, JMenuItem viewList, JMenuItem insertCase, JMenuItem
editCase, JMenuItem deleteCase, JMenuItem metaDataOpCase,JMenuItem maxCasesView) {//throws
Exception
try{
frame = frameOriginal;
Container contentPaneDialog;
JPanel buttonPanel = new JPanel();
// JButtons
JButton cancelButton = new JButton();
JButton printButton = new JButton();
JButton addButton = new JButton();
JButton okButton = new JButton();
JButton deleteAttribute = new JButton();
this.newFind = newFind;
this.viewList = viewList;
this.insertCase = insertCase;
this.editCase = editCase;
this.deleteCase = deleteCase;
this.maxCasesView = maxCasesView;
this.metaDataOpCase = metaDataOpCase;
this.position = position;
this.casesAcces = casesAcces;
this.code = code;
final Vector data;
JPanel titlePanel = new JPanel();
ImageIcon imagen= new ImageIcon ("images/DibujoMetaCase.jpg");
JLabel labelTitle = new JLabel(imagen);
fieldAttribute = new JTextField();
fielDelete = new JTextField();
241
Estudio para la implementación de un sistema de razonamiento basado en casos
// Combobox
comboBox = new JComboBox();
comboBox.addItem("String");
comboBox.addItem("Integer");
comboBox.addItem("Float");
comboBox.addItem("Boolean");
comboBoxVisible = new JComboBox();
comboBoxVisible.addItem("true");
comboBoxVisible.addItem("false");
insertpanel.setLayout(new GridLayout(3,3));
insertpanel.add(new JLabel("Name Attribute : ",JLabel.LEFT));
insertpanel.add(fieldAttribute);
insertpanel.add(new JLabel("Type Attribute : ",JLabel.LEFT));
insertpanel.add(comboBox);
insertpanel.add(new JLabel("Visible Attribute : ",JLabel.LEFT));
insertpanel.add(comboBoxVisible);
deletePanel.setLayout(new GridLayout(1,3));
deletePanel.add(new JLabel("Number Attribute : ",JLabel.LEFT));
deletePanel.add(fielDelete);
deleteAttribute.setText("Delete Attribute");
deleteAttribute.addActionListener(new java.awt.event.ActionListener(){
public void actionPerformed(ActionEvent e) {
deleteAttribute_actionPerformed(e);
}
});
deletePanel.add(deleteAttribute);
resultsPanel.setLayout(new BorderLayout());
resultsPanel.setBorder(BorderFactory.createEmptyBorder(20,20,20,20));
final JDialog dialog = new JDialog(frame);
dialog.setTitle("Metadata case");
tableResults = new JTable();
dispResult = new displayMetaDataCaseNew(frame);
tableResults.setModel(dispResult);
tableResults.setBackground(Color.lightGray);
scrollPane = new JScrollPane(tableResults);
resultsPanel.add(scrollPane, BorderLayout.CENTER);
resultsPanel.add(deletePanel, BorderLayout.NORTH);
resultsPanel.add(insertpanel, BorderLayout.SOUTH);
//buttons
cancelButton.setText("Cancel");
cancelButton.setBounds(100,20,100,20);
cancelButton.addActionListener(new java.awt.event.ActionListener(){
public void actionPerformed(ActionEvent e){
dialog.dispose();
}
});
addButton.setText("Add Attribute");
addButton.setBounds(100,20,100,20);
addButton.addActionListener(new java.awt.event.ActionListener(){
public void actionPerformed(ActionEvent e) {
addButton_actionPerformed(e);
}
});
okButton.setText("ok");
okButton.setBounds(100,20,100,20);
okButton.addActionListener(new java.awt.event.ActionListener(){
public void actionPerformed(ActionEvent e) {
okButton_actionPerformed(e, listMeta, list, dialog);
}
buttonPanel.add(cancelButton, null);
buttonPanel.setLayout(new FlowLayout());
buttonPanel.add(cancelButton);
buttonPanel.add(addButton, null);
buttonPanel.add(addButton);
buttonPanel.add(okButton, null);
buttonPanel.add(okButton);
//dialog inserts
242
});
Estudio para la implementación de un sistema de razonamiento basado en casos
dialog.getContentPane().add(labelTitle,BorderLayout.NORTH);
dialog.getContentPane().add(resultsPanel, BorderLayout.CENTER);
dialog.getContentPane().add(buttonPanel,BorderLayout.SOUTH);
dialog.setSize(new Dimension(500, 465)); // 500 - 300
dialog.setLocationRelativeTo(frame);
dialog.setResizable(false);
dialog.setVisible(true);
}catch (Exception excep) {
JOptionPane.showMessageDialog( frame, "Error:" + excep,
"Error", JOptionPane.ERROR_MESSAGE );
}
}
/** Action Buton detele meta Attribute
* @param ActionEvent e
* @exception Not exception
*/
public void deleteAttribute_actionPerformed( ActionEvent e) {
if (fielDelete.getText().length() > 0){ // if field length > 0
if (!fielDelete.getText().equals("0")){ // if field is diferent of 0
try{
String value = fielDelete.getText();
int number = Integer.parseInt(value);
if (number <= numAttributes){ // if number is bigger that exist
dispResult.deleteFile(number); // delete
fielDelete.setText("");
numAttributes = numAttributes - 1;
}else{
JOptionPane.showMessageDialog( frame, "This number
attribute not exist",
"Error", JOptionPane.ERROR_MESSAGE );
}
// not format number
} catch (NumberFormatException e2) {
JOptionPane.showMessageDialog( frame, "Please insert
number Attribute",
"Error", JOptionPane.ERROR_MESSAGE );
}
}else{
JOptionPane.showMessageDialog( frame, "Reference attribute not
remove",
"Error", JOptionPane.ERROR_MESSAGE );
}
}else{
JOptionPane.showMessageDialog( frame, "Please insert number
Attribute",
"Information",
JOptionPane.INFORMATION_MESSAGE );
}
}
/** Action Buton add Attribute defined
* @param ActionEvent e
* @exception ENot exception
*/
public void addButton_actionPerformed( ActionEvent e) {
if (fieldAttribute.getText().length() > 0){
numAttributes = numAttributes + 1;
dispResult.newFile(fieldAttribute.getText(), (String)comboBox.getSelectedItem(),
243
Estudio para la implementación de un sistema de razonamiento basado en casos
(String)comboBoxVisible.getSelectedItem(),numAttributes);
fieldAttribute.setText("");
}else{ // blank
JOptionPane.showMessageDialog( frame, "Error Insert Attribute:
Attibute is null",
"Information",
JOptionPane.INFORMATION_MESSAGE );
}
}
/** Action Buton save metadata, list of metadata complete
* @param ActionEvent e
* @exception ENot exception
*/
public void okButton_actionPerformed( ActionEvent e, ArrayList listMeta,
ArrayList list, JDialog dialog) {
MetaInfoImpl metaInf;
Vector data = dispResult.getData();
if (dispResult.getRowCount() > 1 ){ // if exist more attributes apart of
reference
for ( int i=0; i<dispResult.getRowCount();i++ ){ // for all Attributes
Vector column = (Vector)data.get(i);
String attribute = (String)column.get(1);
String typeAttribute = (String)column.get(2);
String visible = (String)column.get(3);
metaInf = new MetaInfoImpl();
metaInf.setName_attribute(attribute);
metaInf.setTypeName_attribute(typeAttribute);
if( visible.equals("false")){
metaInf.setIncluded(false);
}
listMeta.add(i,metaInf);
// insert metadata case in list of metadata
}
newFind.setEnabled(true);
viewList.setEnabled(true);
maxCasesView.setEnabled(true);
insertCase.setEnabled(true);
editCase.setEnabled(true);
deleteCase.setEnabled(true);
metaDataOpCase.setEnabled(false);
dialog.dispose();
JOptionPane.showMessageDialog( frame, "MetaDataCase Succesful",
"Information",
JOptionPane.INFORMATION_MESSAGE );
}else{
JOptionPane.showMessageDialog( frame, "Not insert
Attributes",
"Information",
JOptionPane.INFORMATION_MESSAGE );
}
}
//***************************************************************************
//***************************************************************************
/**
Class DisplayMetaDataCaseNew,for create a abstractTableModel of meta Attributes defined
Programmer: Manuel Miguel Gimenez Arjona
Proyect:CBR Extraccion Module
244
Estudio para la implementación de un sistema de razonamiento basado en casos
Directors: Ivan Lopez Arevalo / Aïda Valls Mateu
Departament de Enginyeria Informatica i Matematiques
Universitat Rovira i Virgili
Date: 2.08.2005
*/
class displayMetaDataCaseNew extends AbstractTableModel{
private Vector columnNames = new Vector(1,1);
private Vector data = new Vector(1,1); //rows
Vector columns;
private JFrame frame;
CasesImpl caseView;
ArrayList listTemp;
String attribute;
Vector column;
/** DisplayMetaDataCaseNew, show & Insert refence
* @param JFrame jframe, jframe
* @exception Not Exception
*/
public displayMetaDataCaseNew( JFrame frameX){
columnNames.add("NUMBER");
columnNames.add("ATTRIBUTE");
columnNames.add("DATA TYPE");
columnNames.add("VISIBLE");
columns = new Vector(1,1);
columns.add("0");
columns.add("Reference");
columns.add("String");
columns.add("false");
data.add(columns);
}//constructor
/** get colum size
* @param Not params
* @return return int, Vector size
* @exception Not Exception
*/
public int getColumnCount() {
return columnNames.size();
}
/** get data size
* @param Not params
* @return return int, data size
* @exception Not Exception
*/
public int getRowCount() {
return data.size();
}
/** get vector data
* @param Not param
* @return return Vector, vector data
* @exception Not Exception
*/
public Vector getData() {
return data;
}
/** get column Name
* @param int col, index of column
* @return return String, name of column
* @exception Not Exception
245
Estudio para la implementación de un sistema de razonamiento basado en casos
*/
public String getColumnName(int col) {
return (String)columnNames.elementAt(col);
}
/** get value
* @param int row, index of row
* @param int col, index of column
* @return return object, object that contain position
* @exception Not Exception
*/
public Object getValueAt(int row, int col) {
return ((Vector)data.elementAt(row)).elementAt(col);
}
/** Class column
* @param int c, integer row
* @return return Class, Class of position object
* @exception Not Exception
*/
public Class getColumnClass(int c) {
return getValueAt(0, c).getClass();
}
/** is editable?
* @param int row, integer row
* @param int col, integer column
* @return return boolean, false is editable
* @exception Not Exception
*/
public boolean isCellEditable(int row, int col) {
return false;
}
/** new meta Attribute
* @param String Attribute, nome of attribute
* @param String Visible, true of false
* @param int numAttributes, integer all attributes
* @exception Not Exception
*/
public void newFile(String attribute, String dataType, String visible, int
numAttributes){
columns = new Vector(1,1);
columns.add(String.valueOf(numAttributes));
columns.add(attribute);
columns.add(dataType);
columns.add(visible);
data.add(columns);
fireTableDataChanged(); // actualizate Table
}
/** delete Attribute
* @param int file, file of table
* @return int numAttributes
* @exception Not Exception
*/
public void deleteFile(int file){
int newNumber = 0;
Vector column;
Vector newColumn;
Vector newData = new Vector(1,1);
for (int i=0; i<=numAttributes;i++ ){ // for all Attributes
if ( i != file) { // if is file delete not insert in new Data
column = (Vector)data.get(i);
246
Estudio para la implementación de un sistema de razonamiento basado en casos
String attribute = (String)column.get(1);
String typeAttribute = (String)column.get(2);
String visible = (String)column.get(3);
newColumn = new Vector(1,1);
newColumn.add(String.valueOf(newNumber));
newColumn.add(attribute);
newColumn.add(typeAttribute);
newColumn.add(visible);
newData.add(newColumn);
newNumber = newNumber + 1;
}
}
data.removeAllElements(); // remove all data
data = newData;
// new data
fireTableDataChanged(); // actualizate Table
}
}
}
//--- ResultsWindow
*******************************************************************************************
WindowProgressBarReloaded.java
*******************************************************************************************
/**
Class for display the progressbar in reloading cases
Programmer: Manuel Miguel Gimenez Arjona
Proyect:CBR Extraccion Module
Directors: Ivan Lopez Arevalo / Aïda Valls Mateu
Departament de Enginyeria Informatica i Matematiques
Universitat Rovira i Virgili
Date: 2.08.2005
*/
package cbr;
import
import
import
import
import
import
java.io.*;
java.awt.*;
java.util.*;
javax.swing.*;
java.awt.event.*;
net.sourceforge.selectionengine.*;
public class WindowProgressBarReload extends JPanel{
/** WindowprogressbarReload
* @param JFrame frameOriginal,main Frame
* @param Hashtable casesAcces, hash table for inmediat acces
* @param ArrayList list, list of cases
* @exception not exception
*/
public WindowProgressBarReload(JFrame frameOriginal, Hashtable casesAcces, ArrayList
list) {//throws Exception
// var
ArrayList listTemp = new ArrayList();
Hashtable casesHash = new Hashtable();
int number = 0;
CasesImpl casesNew;
247
Estudio para la implementación de un sistema de razonamiento basado en casos
final JFrame frame = frameOriginal;
Container contentPaneDialog;
final JDialog dialog = new JDialog(frame);
JPanel panelProgress = new JPanel();
JProgressBar progress = new JProgressBar();
JLabel label1 = new JLabel( "PROGRESS DATABASE CASES RELOAD......");
label1.setPreferredSize( new Dimension( 280, 34 ) );
JLabel label2 = new JLabel( "Number of Cases:" );
label2.setPreferredSize( new Dimension( 280, 34 ) );
// progres bar
progress.setStringPainted(true);
progress.setMinimum( 0 );
progress.setMaximum( list.size() + 1 ); // set max progress bar
progress.setValue( 0 );
progress.setBounds( 20, 35, 260, 20 );
progress.setPreferredSize( new Dimension( 280, 25 ) );
panelProgress.add(label1);
panelProgress.add(progress);
panelProgress.add(label2);
//title
dialog.setTitle("Progress");
dialog.getContentPane().add(panelProgress);
dialog.setSize(new Dimension(300, 150));
dialog.setLocationRelativeTo(frame);
dialog.setResizable(false);
dialog.setVisible(true);
Iterator itCases = list.iterator();
while (itCases.hasNext()) { // while exist cases
label1.setText( "PROGRESS DATABASE CASES RELOAD..." );
Rectangle labelRect = label1.getBounds();
labelRect.x = 0;
labelRect.y = 0;
label1.paintImmediately( labelRect );
label2.setText( "NUMBER OF CASES: " + number);
Rectangle labelRect2 = label2.getBounds();
labelRect2.x = 0;
labelRect2.y = 0;
label2.paintImmediately( labelRect2 );
casesNew = (CasesImpl)itCases.next(); // next case
listTemp = casesNew.list();
String attribute = (String)listTemp.get(0);// reference
casesAcces.put(attribute, casesNew ); // insert in hash table
number = number + 1 ;
progress.setValue( number );
Rectangle progressRect =
progress.getBounds();
progressRect.x = 0;
progressRect.y = 0;
progress.paintImmediately( progressRect );
}
dialog.dispose();
JOptionPane.showMessageDialog( frame, "DataBase Reload
Complete",
"Information",
JOptionPane.INFORMATION_MESSAGE );
}
}
248