Estudio para la implementación de un sistema de...

PROYECTO FINAL DE CARRERA

Estudio para la implementación de un

sistema de razonamiento basado en casos

Manuel Miguel Giménez Arjona,

[email protected]

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

11

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.


22

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


33

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


44

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.


55

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.


66

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.


77

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


88

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.


99

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.


1100

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.

Figura 1. Esquema de representación de una base de casos.

C A S O 1

SOLUCION CAMBIAR CARTUCHO DE TINTA

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

C A S O 2

C A S O N

SOLUCION CAMBIAR CARTUCHO DE TINTA

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 REPONER PAPEL EN LA IMPRESORA

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

BASE DE

CASOS


1111

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.

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.

Espacio de Problemas

Espacio de Soluciones

Descripción del problema nuevo

Solución Propuesta al nuevo caso


1122

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


1133

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.


1144

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.


1155

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.


1166

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.


1177

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


1188

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


1199

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 :


2200

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.


2211

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


2222

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:


2233

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:


2244

• 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 (Re-

aplication 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


2255

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.


2266

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.


2277

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


2288

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.


2299

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.


3300

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.


3311

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.


3322

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.


3333

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.


3344

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.


3355

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


3366

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


3377

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.


3388

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 (padre-

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


3399

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.


4400

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

4411

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


4422

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

4433

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


4444

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.


4455

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:


4466

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


4477

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.


4488

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


4499

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


5500

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


5511

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.


5522

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.


5533

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.


5544

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

nearest 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

D

C

A

Target

B

0

2

4

6

8

10

0 2 4 6 8 10Price

Perfo

rm

an

ce

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:


5555

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)


5566

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.


5577

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.

5588

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


5599

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:

6600

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:

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.

f=s:marca |s:modelo|i:coste| b:sumergible d=Lotus |rp-320 |500 | y d=Casio |f-91w |6 | n d=Casio |f-245g |100 | y d=Swatch |qwe-56 |50 | n d= Gucci | ee -123 |600 | y d= Gucci | et -54 |1000 | y

c | marca | !% | Casio c | marca | != | Gucci w | marca | 2 c | coste | <= | 50 c | coste | ~ | 30 w | coste | 4

6611

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


6622

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.


6633

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)


6644

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


6655

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


6666

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


6677

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


6688

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


6699

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


7700

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


7711

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.


7722

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


7733

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.

7744

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)

7755

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.


7766

Figura 28. Ejemplo 1

Figura 29. 100 % de similitud al aplicar una búsqueda sencilla


7777

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


7788

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.


7799

• 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


8800

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 “ciencia-

ficció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


8811

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


8822

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,


8833

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.


8844

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


8855

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.


8866

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.


8877

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


8888

[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”, Addison-

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


8899

[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


9900

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

4, 12-13. Octover 2002


9911

[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


9922

APÉNDICES


9933

Apéndice A. Resumen de herramientas CBR

Herramientas académicas

Herramienta Entorno Dominio

Aplicación

Representación Recuperación Adaptación Interfaz

CASPIAN MS-DOS

MAC

General Simple, se almacena

en un archivo ASCII

Nearest Neighbor Mediante Reglas Línea de comandos

SELECTION

ENGINE

Cualquier computadora que contenga

la maquina virtual de Java, PCs

Windows 95/98/NT, Sun Solaris y

Macintosh, plataformas Unix

General Simple, se almacena en

un fichero

Nearest Neighbor No dispone Entorno gráfico

NaCoDAE Cualquier computadora que contenga




Tareas de

asistencia naval

Estructurada,

representación orientada

a objetos

Librería de casos

K-nearest

neighbour

No dispone Entorno gráfico

IUCBRF Cualquier computadora que contenga




General En tres tipos:

1.-Almacenados en una

lista desordenada

2.- Archivo

B-tree-bached

3.- D-tree

K-nearest

neighbour

Tres propuestas:

1.- No

Adaptation

2.- Weighted

Average

3.- Weighted

Majority

No aplicable

CBR-Shell Mozilla 1.2, Linux, Explorer 6.0,

Windows XP y Mac OS

General Simple, se almacena

en un archivo ASCII

nearest neighbor y

k-nearest neighbor

Medidas de

confianza

adaptativas

Applet java


9944

Herramientas comerciales


Aplicación


KATE Pc Windows, UNIX Sistemas inteligentes de

soporte de decisiones

Casos jerarquicos Nearest neighbor e inducción,

tecnicas de data mining, medidas

de similitud y pesos

No dispone Intefaz personalizable

CBR-Works MS Windows,

MAC, OS/2, UNIX

Sistemas de

clasificación, comercio

electrónico, data

mining, selección de

productos

Modelos de dominio y

casos con representación

orientada a objetos

nearest neighbor e inducción Usando reglas Entorno gráfico sencillo

de usar. Genera

aplicaciones CBR con

interfaz o servidores

Orenge Independiente de la

Plataforma

Sistemas Inteligentes de

búsqueda de

información

Flexible Flexible y extensible.Busquedas

exactas, basadas en similitud y

difusas

Reglas muy

simples

No aplicable

ReMind Pc Windows,

MAC, UNIX

General Casos planos anidados y

jerarquías ordenadas de

símbolos

nearest neighbor, inducción y

plantillas (para consultas a bases

de datos)

Mediante

formulas

Interfaz de desarrollo que

se puede personalizar


9955


Aplicación


ReCall Pc Windows,

UNIX

General Estructurada. Casos jerárquicos

con relaciones. Representación

orientada a objetos. Herencia.

nearest neighbor e inducción Reglas definidas por

expertos y funciones

Entorno gráfico de

desarrollo

ESTEEM Pc Windows General.

Diagnostico

Atención al cliente.

Estructurada. Orientada a

objetos. Casos anidados.

nearest neighbor con

generación inductiva de pesos.

Se pueden añadir funciones de

similitud propias.

Usando funciones y

reglas

GUI Builder basado

en formularios

ART*Enterprise Gran variedad

de entornos

General Atributo-valor con muchos

tipos predefinidos. Orientada a

objetos

nearest neighbor Funciones, reglas y

técnicas basadas en el

conocimiento

Incluye un

constructor de

interfaces gráficas

para usuario


9966

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


9977

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


9988

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


9999

Constructor Summary

CBRProgram()

Method Summary

static void main(java.lang.String[] args) Main of Program

(package private)

void

run() Metod 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) void

cancelButton_actionPerformed() Action button Cancel in Similarity Search


deleteCase_actionPerformed

(java.awt.event.ActionEvent e) Action button delete Case


110000


disConnectionOzone_actionPerformed

(java.awt.event.ActionEvent e) Action button Disconnect Ozone


editCase_actionPerformed

(java.awt.event.ActionEvent e) Action Button Edit case


exit_actionPerformed(java.awt.event.ActionEvent e) Action button Exit Program


exitWindow(java.awt.event.WindowEvent e) Action button Exit Program window


help_actionPerformed(java.awt.event.ActionEvent e) Action button Help

void iniciateQuery() Iniciate new search similar attributes

private void init() Iniciate Window query with attributes CaseBase and criterion search


insertCase_actionPerformed

(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


maxCasesView_actionPerformed

(java.awt.event.ActionEvent e) Action button View max cases and define number max


metaDataOpCase_actionPerformed

(java.awt.event.ActionEvent e) Action Button MetaDAtaCase insert, Show Window Insert Metadata

void montar_Menubar() Iniciate MenuBar of Aplication & Submenus


newfind_actionPerformed(java.awt.event.ActionEvent e) Action button New Find Similarity


openDb_actionPerformed(java.awt.event.ActionEvent e) 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


submitButton_actionPerformed

(java.awt.event.ActionEvent e) Action button Similarity Cases, find similar cases


viewList_actionPerformed

(java.awt.event.ActionEvent e) Action button View List of cases, Show Window all cases


110011

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.


110022

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


110033

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 java.lang.String

operatorToString(int operator) 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


110044

Constructor Summary

FilterEngine()

Method Summary

Items filterItems(Items items, FilterCriteria filterCriteria) Return Items filtered

private boolean

violatesCriteria(Item item, FilterCriteria criteria) 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)


110055

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)


110066

protected void add(TraitDescriptors traitDescriptors, java.util.ArrayList caseItem) 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

private void setValues(java.util.ArrayList newValues) 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


110077

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


110088

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 |


110099

+--cbr.OrdenacionInteger


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


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


111100

Constructor Summary

OzoneProgram()

Method Summary

static void main(java.lang.String[] args) main

(package private)

void

run() Run, 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 private)

void

connectionOzone_actionPerformed(java.awt.event.ActionEvent e) Connection Database of Ozone

(package private)

void

exit_actionPerformed(java.awt.event.ActionEvent e) Exit program

(package private)

void

exitWindow(java.awt.event.WindowEvent e) Exit window

(package help_actionPerformed(java.awt.event.ActionEvent e)


111111

private) void

help of Aplication

void montar_Menubar() Create the menubar of ozone Window

(package private)

void

newCreateDb_actionPerformed(java.awt.event.ActionEvent e) Create a new Database of Ozone

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


111122

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


111133

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


111144

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 java.lang.String

operatorToString(int operator) 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


111155

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

111166

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 void

setItem(Item newItem) Set Item

protected void

setPercentSimilarity(float newPercentMatch) Set percent Similaruty

protected void

setRank(int newRank) Set Rank

SimilarityEngine.java

net.sourceforge.selectionengine Class SimilarityEngine

java.lang.Object | +--net.sourceforge.selectionengine.SimilarityEngine


111177

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 SimilarityCriterionScores

getTargetValues

(TraitDescriptors traitDescriptors, SimilarityCriteria criteria, SimilarityWeights weights, DataSetStatistics statistics) Get values of the case target

private SimilarityCriterionScores

normalizeValues(Item item, SimilarityCriteria criteria, SimilarityWeights weights, DataSetStatistics statistics) Nomralized values of item

SimilarityWeight.java

net.sourceforge.selectionengine Class SimilarityWeight

java.lang.Object | +--net.sourceforge.selectionengine.SimilarityWeight


111188

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


111199

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

TraitDescriptor(java.lang.String name, java.lang.String type, boolean included) Construct traitDescriptor

Method Summary

int getDataType() Return DataType

boolean getIncluded() Return is visible?


112200

java.lang.String getName() Return Name Attribute

private int obtainDataType(java.lang.String dataType) Return Numeric value

private int stringToDataType(java.lang.String dataType) 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


112211

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


112222

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


112233

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


112244

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


112255

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


112266

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


112277

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


112288

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


112299

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*/ } *******************************************************************************************


113300

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 ); }


113311

/**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; }


113322

/**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

*******************************************************************************************


113333

/** 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 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; 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;


113344

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 }


113355

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(); panel3 = new JPanel(); panel4 = new JPanel(); panel5 = new JPanel(); panel6 = new JPanel(); panel7 = new JPanel(); 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( panel1 ); headerLinePanel.add( panel2 ); headerLinePanel.add( panel3 ); headerLinePanel.add( panel4 ); headerLinePanel.add( panel5 ); headerLinePanel.add( panel6 ); headerLinePanel.add( panel7 ); 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?


113366

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


113377

}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(); panel2 = new JPanel(); panel3 = new JPanel(); panel4 = new JPanel(); panel5 = new JPanel(); panel6 = new JPanel(); panel7 = 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);


113388

}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);


113399

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() {


114400

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); }

114411

} // 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("<=");


114422

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;

114433

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,


114444

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; value = null; component = null; components = null; matchedItems = null; panel = null; stats = null; filterEngine = null; resultsWindow = null; similarItems = null; filterCriteria = null; similarityEngine = null; similarityCriteria = null; similarityWeights = null; similarity = false; } /**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" + " [email protected]\n\n" + "DIRECTORS:\n" + " Ivan Lopez Arevalo / Aïda Valls Mateu\n" + " [email protected] / [email protected]\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" + " [email protected]\n" + " [email protected]\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);


114455

} /**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);


114466

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,


114477

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 {

114488

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 baylor * */ public class DataSetStatistics { //----------------------------------------------------------------------------- // Attributes //----------------------------------------------------------------------------- HashMap dataSetStatistics; //--- collection of TraitStatistics


114499

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


115500

//--- 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 */

115511

public class ExampleFileFilter extends FileFilter { private static String TYPE_UNKNOWN = "Type Unknown"; private static String HIDDEN_FILE = "Hidden File"; private Hashtable filters = null; private String description = null; private String fullDescription = null; private 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]); }

115522

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


115533

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

*******************************************************************************************

/**

115544

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 baylor * */ 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

115555

*******************************************************************************************

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 baylor * */ 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() {


115566

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

115577

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

115588

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 baylor * */ 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;


115599

} //--- 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){


116600

//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);

116611

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 baylor *


116622

*/ 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

116633

*******************************************************************************************

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 baylor * */ 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.

116644

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 baylor * */ 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


116655

/** 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();


116666

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;


116677

/**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.


116688

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

116699

*/ 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

117700

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 ) ); }


117711

} *******************************************************************************************

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 */


117722

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


117733

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" + " [email protected]\n\n" + "DIRECTORS:\n" + " Ivan Lopez Arevalo / Aïda Valls Mateu\n" + " [email protected] / [email protected]\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) {


117744

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


117755

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

*******************************************************************************************

**


117766

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


117777

} } /**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",


117788

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


117799

} } } /**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 java.io.*; import java.awt.*; import java.util.*; import javax.swing.*; import java.awt.event.*; import java.awt.print.*; import java.text.DecimalFormat; import java.awt.print.PrinterJob; import net.sourceforge.selectionengine.*; import 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

118800

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. "));


118811

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 ); }


118822

}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;

118833

/** 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>CBR - EXTRACTION MODULE </CENTER>"; HTML = HTML + "<CENTER>Results of Similar Cases </CENTER>"; HTML = HTML + "<table border=2 align=center cellspacing=0 bordercolor=#000000>"; //--- Column headers HTML = HTML + "<tr>"; HTML = HTML + "<th " + "align=center" + " bgcolor=#FF9900" + ">"; HTML = HTML + "Rank"; HTML = HTML + "</th>"; HTML = HTML + "<th " + "align=center" + " bgcolor=#99CC00" + ">"; 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" + ">"; 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 ;

118844

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(); }

118855

/** 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 baylor * */ public class SimilarItems { //----------------------------------------------------------------------------- // Attributes //----------------------------------------------------------------------------- //--- Sorted list of SimilarityDescription objects private ArrayList descriptions = new ArrayList(); //----------------------------------------------------------------------------- // Methods //----------------------------------------------------------------------------- /** add collection similar items * @param SimilarityDescription descriptor, item similarity

118866

* @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) {

118877

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; //--- +1 to compensate

118888

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 baylor */ 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


118899

*/ 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 = 3; //----------------------------------------------------------------------------- // Attributes //----------------------------------------------------------------------------- private String fieldName; private int operator; private TraitValue value; //----------------------------------------------------------------------------- // Constructors


119900

//----------------------------------------------------------------------------- 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()

119911

{ 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 baylor * */ public class SimilarityCriterionScore { //----------------------------------------------------------------------------- // Attributes //----------------------------------------------------------------------------- private String criterionID; private float normalizedValue; private float weightedValue; //----------------------------------------------------------------------------- // Constructors //----------------------------------------------------------------------------- protected SimilarityCriterionScore( String criterionID ) { setID( criterionID ); } //-----------------------------------------------------------------------------

119922

// 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 baylor * */

119933

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 baylor * */ public class SimilarityDescription implements Comparable { //----------------------------------------------------------------------------- // Attributes //----------------------------------------------------------------------------- private Item itemBeingDescribed;

119944

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

119955

*/ 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 baylor * */ 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);


119966

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


119977

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; //--- Isn't there a square operator in Java like ^? 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 ) {


119988

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,


119999

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


220000

//--- 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;

220011

/** 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 baylor * */ 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


220022

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

220033

This class has been modified to comment the methods modified by Manuel Miguel Gimenez Arjona */ package net.sourceforge.selectionengine; /** * * @author baylor * */ 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


220044

*******************************************************************************************

/** 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 BOOLEAN_ABBREVIATION = "b"; private static final String FLOAT_ABBREVIATION = "f"; private static final String INTEGER_ABBREVIATION = "i"; private static final String STRING_ABBREVIATION = "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; }


220055

/** 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( ) {


220066

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 */


220077

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++; // } }


220088

} 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


220099

//--------------------------------------------------------------------------- /** 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() {


221100

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;


221111

} /** 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; }


221122

/** 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

*******************************************************************************************

/*

221133

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 baylor * */ 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


221144

* @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


221155

{ //----------------------------------------------------------------------------- // 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(); }


221166

} //--- 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(); } /**


221177

* 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 java.io.*; import java.awt.*; import java.util.*; import javax.swing.*; import java.awt.event.*; import java.awt.print.*; import java.text.DecimalFormat; import java.awt.print.PrinterJob; import net.sourceforge.selectionengine.*; import 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();


221188

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


221199

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;

222200

/** 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 */


222211

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 java.io.*; import java.awt.*; import java.util.*; import javax.swing.*; import java.awt.event.*; import java.awt.print.*; import java.text.DecimalFormat; import java.awt.print.PrinterJob; import net.sourceforge.selectionengine.*; import javax.swing.table.AbstractTableModel;


222222

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(); } });


222233

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

222244

}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


222255

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 */


222266

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",


222277

"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 java.io.*; import java.awt.*; import java.util.*; import javax.swing.*; import java.awt.event.*; import java.awt.print.*; import java.text.DecimalFormat; import java.awt.print.PrinterJob; import net.sourceforge.selectionengine.*; import 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();


222288

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 */


222299

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;

223300

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); }


223311

}//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){


223322

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); } } }


223333

*******************************************************************************************

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 java.io.*; import java.awt.*; import java.util.*; import javax.swing.*; import java.awt.event.*; import java.awt.print.*; import java.text.DecimalFormat; import java.awt.print.PrinterJob; import net.sourceforge.selectionengine.*; import 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


223344

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;

223355

/** 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


223366

* @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


223377

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 java.awt.print.*; import java.text.DecimalFormat; import java.awt.print.PrinterJob; import net.sourceforge.selectionengine.*; import 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


223388

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");

223399

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); }


224400

/** 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 java.io.*; import java.awt.*; import java.util.*; import javax.swing.*; import java.awt.event.*; import java.awt.print.*; import java.text.DecimalFormat; import java.awt.print.PrinterJob; import net.sourceforge.selectionengine.*; import 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;


224411

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();


224422

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

224433

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(),

224444

(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


224455

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

224466

*/ 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);


224477

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 java.io.*; import java.awt.*; import java.util.*; import javax.swing.*; import java.awt.event.*; import 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;


224488

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 ); } }

Estudio para la implementación de un sistema de...

Documents

Transcript of Estudio para la implementación de un sistema de...