PROYECTO FINAL DE CARRERA
Estudio para la implementación de un
sistema de razonamiento basado en casos
Manuel Miguel Giménez Arjona,
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.
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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.
Estudio para la implementación de un sistema de razonamiento basado en casos
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.
Estudio para la implementación de un sistema de razonamiento basado en casos
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.
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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.
Estudio para la implementación de un sistema de razonamiento basado en casos
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.
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en 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
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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.
Estudio para la implementación de un sistema de razonamiento basado en casos
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.
Estudio para la implementación de un sistema de razonamiento basado en casos
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.
Estudio para la implementación de un sistema 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.
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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].
Estudio para la implementación de un sistema de razonamiento basado en casos
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 :
Estudio para la implementación de un sistema de razonamiento basado en casos
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.
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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:
Estudio para la implementación de un sistema de razonamiento basado en casos
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:
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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.
Estudio para la implementación de un sistema de razonamiento basado en casos
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.
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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.
Estudio para la implementación de un sistema de razonamiento basado en casos
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.
Estudio para la implementación de un sistema de razonamiento basado en casos
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.
Estudio para la implementación de un sistema de razonamiento basado en casos
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.
Estudio para la implementación de un sistema de razonamiento basado en casos
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.
Estudio para la implementación de un sistema de razonamiento basado en casos
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.
Estudio para la implementación de un sistema de razonamiento basado en casos
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.
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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.
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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.
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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 -.
Estudio para la implementación de un sistema de razonamiento basado en casos
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.
Estudio para la implementación de un sistema de razonamiento basado en casos
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:
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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.
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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.
Estudio para la implementación de un sistema de razonamiento basado en casos
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.
Estudio para la implementación de un sistema de razonamiento basado en casos
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.
Estudio para la implementación de un sistema de razonamiento basado en casos
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:
Estudio para la implementación de un sistema de razonamiento basado en casos
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)
Estudio para la implementación de un sistema de razonamiento basado en casos
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.
Estudio para la implementación de un sistema de razonamiento basado en 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.
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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:
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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.
Estudio para la implementación de un sistema de razonamiento basado en casos
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)
Estudio para la implementación de un sistema de razonamiento basado en casos
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.
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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.
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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.
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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.
Estudio para la implementación de un sistema de razonamiento basado en casos
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)
Estudio para la implementación de un sistema de razonamiento basado en casos
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.
Estudio para la implementación de un sistema de razonamiento basado en casos
7766
Figura 28. Ejemplo 1
Figura 29. 100 % de similitud al aplicar una búsqueda sencilla
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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.
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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,
Estudio para la implementación de un sistema de razonamiento basado en 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.
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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.
Estudio para la implementación de un sistema de razonamiento basado en casos
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.
Estudio para la implementación de un sistema de razonamiento basado en casos
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.
Estudio para la implementación de un sistema de razonamiento basado en casos
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.
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
9922
APÉNDICES
Estudio para la implementación de un sistema de razonamiento basado en casos
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
la maquina virtual de Java, PCs
Windows 95/98/NT, Sun Solaris y
Macintosh, plataformas Unix
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
la maquina virtual de Java, PCs
Windows 95/98/NT, Sun Solaris y
Macintosh, plataformas Unix
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
Estudio para la implementación de un sistema de razonamiento basado en casos
9944
Herramientas comerciales
Herramienta Entorno Dominio
Aplicación
Representación Recuperación Adaptación Interfaz
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
Estudio para la implementación de un sistema de razonamiento basado en casos
9955
Herramienta Entorno Dominio
Aplicación
Representación Recuperación Adaptación Interfaz
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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
(package private) void
deleteCase_actionPerformed
(java.awt.event.ActionEvent e) Action button delete Case
Estudio para la implementación de un sistema de razonamiento basado en casos
110000
(package private) void
disConnectionOzone_actionPerformed
(java.awt.event.ActionEvent e) Action button Disconnect Ozone
(package private) void
editCase_actionPerformed
(java.awt.event.ActionEvent e) Action Button Edit case
(package private) void
exit_actionPerformed(java.awt.event.ActionEvent e) Action button Exit Program
(package private) void
exitWindow(java.awt.event.WindowEvent e) Action button Exit Program window
(package private) void
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
(package private) void
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
(package private) void
maxCasesView_actionPerformed
(java.awt.event.ActionEvent e) Action button View max cases and define number max
(package private) void
metaDataOpCase_actionPerformed
(java.awt.event.ActionEvent e) Action Button MetaDAtaCase insert, Show Window Insert Metadata
void montar_Menubar() Iniciate MenuBar of Aplication & Submenus
(package private) void
newfind_actionPerformed(java.awt.event.ActionEvent e) Action button New Find Similarity
(package private) void
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
(package private) void
submitButton_actionPerformed
(java.awt.event.ActionEvent e) Action button Similarity Cases, find similar cases
(package private) void
viewList_actionPerformed
(java.awt.event.ActionEvent e) Action button View List of cases, Show Window all cases
Estudio para la implementación de un sistema de razonamiento basado en casos
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.
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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)
Estudio para la implementación de un sistema de razonamiento basado en casos
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)
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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 |
Estudio para la implementación de un sistema de razonamiento basado en casos
110099
+--cbr.OrdenacionInteger
All Implemented Interfaces: java.util.Comparator
Constructor Summary
OrdenacionInteger()
Method Summary
int compare(java.lang.Object obj1, java.lang.Object obj2) Compare two objects type Integer
Ordenacion Nombre.java
cbr Class OrdenacionNombre
java.lang.Object | +--cbr.OrdenacionNombre
All Implemented Interfaces: java.util.Comparator
Constructor Summary
OrdenacionNombre()
Method Summary
int compare(java.lang.Object obj1, java.lang.Object obj2) Compare two objects type String
OzoneProgram.java
cbr Class OzoneProgram
java.lang.Object | +--cbr.OzoneProgram
Estudio para la implementación de un sistema de razonamiento basado en casos
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)
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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()
Estudio para la implementación de un sistema de razonamiento basado en casos
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()
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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()
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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?
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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*/ } *******************************************************************************************
Estudio para la implementación de un sistema de razonamiento basado en casos
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 ); }
Estudio para la implementación de un sistema de razonamiento basado en casos
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; }
Estudio para la implementación de un sistema de razonamiento basado en casos
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
*******************************************************************************************
Estudio para la implementación de un sistema de razonamiento basado en casos
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;
Estudio para la implementación de un sistema de razonamiento basado en casos
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 }
Estudio para la implementación de un sistema de razonamiento basado en casos
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?
Estudio para la implementación de un sistema de razonamiento basado en casos
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);
Estudio para la implementación de un sistema de razonamiento basado en casos
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);
Estudio para la implementación de un sistema de razonamiento basado en casos
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);
Estudio para la implementación de un sistema de razonamiento basado en casos
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() {
Estudio para la implementación de un sistema de razonamiento basado en casos
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); }
Estudio para la implementación de un sistema de razonamiento basado en casos
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("<=");
Estudio para la implementación de un sistema de razonamiento basado en casos
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;
Estudio para la implementación de un sistema de razonamiento basado en casos
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,
Estudio para la implementación de un sistema de razonamiento basado en casos
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);
Estudio para la implementación de un sistema de razonamiento basado en casos
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);
Estudio para la implementación de un sistema de razonamiento basado en casos
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,
Estudio para la implementación de un sistema de razonamiento basado en casos
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 {
Estudio para la implementación de un sistema de razonamiento basado en casos
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 <small>baylor</small> * */ public class DataSetStatistics { //----------------------------------------------------------------------------- // Attributes //----------------------------------------------------------------------------- HashMap dataSetStatistics; //--- collection of TraitStatistics
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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 */
Estudio para la implementación de un sistema de razonamiento basado en casos
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]); }
Estudio para la implementación de un sistema de razonamiento basado en casos
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) {
Estudio para la implementación de un sistema de razonamiento basado en casos
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
*******************************************************************************************
/**
Estudio para la implementación de un sistema de razonamiento basado en casos
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 <small>baylor</small> * */ public class FilterCriteria { //--- Here's where we hold all our data private ArrayList data = new ArrayList(); /** Add collection of filterCriterion * @param String field, name of attribute * @param String operator, operator criterion * @param String value, value of attribute * @exception Not Exceptions */ public void add( String field, String operator, String value ) { FilterCriterion criterion = new FilterCriterion( field, operator, value ); data.add( criterion ); } //--- add /** * This has to return Object because that's how * it's defined in the super class */ public Object clone( ) { FilterCriteria newFilterCriteria = new FilterCriteria(); newFilterCriteria.setValues( data ); return (Object) newFilterCriteria; } //--- clone /** Iterator * @param Not params * @return Iterator * @exception Not Exceptions */ public Iterator iterator() { return data.iterator(); } /** Set values * @param ArrayList newValues, arraylist new * @exception Not Exceptions */ private void setValues( ArrayList newValues ) { data = (ArrayList) newValues.clone(); } /** get int Size * @param Not params * @return int size of collection * @exception Not Exceptions */ public int size() { return data.size(); } } //--- FilterCriteria
Estudio para la implementación de un sistema de razonamiento basado en casos
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 <small>baylor</small> * */ public class FilterCriterion { //----------------------------------------------------------------------------- // Public constants //----------------------------------------------------------------------------- public static final int OPERATOR_UNKNOWN = 0; public static final int OPERATOR_EQUALS = 1; public static final int OPERATOR_NOT_EQUAL = 2; public static final int OPERATOR_GREATER_THAN = 3; public static final int OPERATOR_GREATER_THAN_OR_EQUAL = 4; public static final int OPERATOR_LESS_THAN = 5; public static final int OPERATOR_LESS_THAN_OR_EQUAL = 6; //----------------------------------------------------------------------------- // Attributes //----------------------------------------------------------------------------- protected String fieldName; protected int operator; protected TraitValue value; //----------------------------------------------------------------------------- // Constructors //----------------------------------------------------------------------------- protected FilterCriterion( String fieldName, String operator, String value ) { this.fieldName = fieldName; this.operator = stringToOperator( operator ); this.value = new TraitValue( value ); } //--- constructor //----------------------------------------------------------------------------- // Methods //----------------------------------------------------------------------------- /** Return String Attribute * @param not params * @return String fieldName, name Attribute * @exceptions Not Exceptions */ public String getFieldName() { return fieldName; } /** Return integer Operator * @param not params * @return integer Operator * @exceptions Not Exceptions */ public int getOperator() { return operator; } /** Return String Opertor * @param not params * @return String Operator * @exceptions Not Exceptions */ public String getOperatorAsString() {
Estudio para la implementación de un sistema de razonamiento basado en casos
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 ) {
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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 <small>baylor</small> * */ public class FilterEngine { /** Return Items filtered * @param Items items, Tems for filter * @param FilterCriteria filterCriteria, criterions user * @return Items filteredItems, Items filtered * @exceptions Not Exceptions */ public Items filterItems( Items items, FilterCriteria filterCriteria ) { Items filteredItems = new Items( items.getTraitDescriptors() ); Item item; Iterator itemsCursor; boolean var; //--- Go through each item and see if violates any of our rules itemsCursor = items.iterator(); while (itemsCursor.hasNext()) { item = (Item) itemsCursor.next(); //--- Does this item violate any of our filter criteria? var = violatesCriteria( item, filterCriteria ); //System.out.println (var); if (!(var)) { //--- It didn't violate any criteria so let's keep this one //System.out.println ("adiciona a filteredItems "); filteredItems.add( item ); } } //--- while hasNext return filteredItems;
Estudio para la implementación de un sistema de razonamiento basado en casos
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){
Estudio para la implementación de un sistema de razonamiento basado en casos
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);
Estudio para la implementación de un sistema de razonamiento basado en casos
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 <small>baylor</small> *
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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 <small>baylor</small> * */ public class ItemManager { //--- Static for performance. i don't want to have each instance //--- of this load its own data from the data source private TraitDescriptors traitDescriptors = new TraitDescriptors(); private Items items = new Items( traitDescriptors ); CasesImpl casesNew; /** Add Cases to collection Items * @param ArrayList listMeta, list metacases * @param ArrayList listCases, list cases * @exceptions Not Exceptions */ public ItemManager( ArrayList listMeta, ArrayList listCases) throws Exception { //added by Manuel Miguel Gimenez Arjona traitDescriptors.loadTraitDescriptorOfCase(listMeta); //load traitdescriptors Iterator itCases = listCases.iterator(); int i= 0; while (itCases.hasNext()) { casesNew = (CasesImpl)itCases.next(); items.add( getTraitDescriptors(), casesNew.list() ); i++; } } /** getItems * @param Not params * @return Items * @exceptions Not Exceptions */ public Items getItems() { return items; } /** get TraitDescriptors * @param Not params * @return TraitDescriptors * @exceptions Not Exceptions */ public TraitDescriptors getTraitDescriptors() { return traitDescriptors; } } *******************************************************************************************
Items.java
*******************************************************************************************
/** This class Ítems is the object that contains one collection of objects Item.
Estudio para la implementación de un sistema de razonamiento basado en casos
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 <small>baylor</small> * */ public class Items { //----------------------------------------------------------------------------- // Attributes //----------------------------------------------------------------------------- ArrayList data = new ArrayList(); TraitDescriptors traitDescriptors; //----------------------------------------------------------------------------- // Constructors //----------------------------------------------------------------------------- /** * This is the only constructor and it requires TraitDescriptors * Technically, Items doesn't need to know anything about TraitDescriptors, * but a lot of the people who use Items (actually, Item) do. * They could create their own copy, but that would be slow, what with * all the loading and what not. Ditto for storing it with each Item. * So storing TraitDescriptors here is just a minor performance tuning thingy */ protected Items( TraitDescriptors traitDescriptors ) { this.traitDescriptors = traitDescriptors; } //--- constructor //----------------------------------------------------------------------------- // Methods //----------------------------------------------------------------------------- protected void add( Item item ) { data.add( item ); } //--- add /** This method create Item and asociate your traitDescriptors and arraylist of collection attribute - value. Finally insert at collection Items * @param TraitDescriptors traitDescriptors, collection description Attributes * @param ArrayList caseItem, caseItem * @exception Not Exceptions */ protected void add( TraitDescriptors traitDescriptors, ArrayList caseItem ) { Item item = new Item( traitDescriptors ); item.loadFromDelimitedCase( traitDescriptors, caseItem ); this.add( item ); } //--- add /** clone Items and return * @param not params * @return Object * @exception Not Exceptions */ public Object clone( ) { Items newItems = new Items( traitDescriptors ); newItems.setValues( data ); return (Object) newItems; } //--- clone
Estudio para la implementación de un sistema de razonamiento basado en casos
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();
Estudio para la implementación de un sistema de razonamiento basado en casos
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;
Estudio para la implementación de un sistema de razonamiento basado en casos
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.
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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 ) ); }
Estudio para la implementación de un sistema de razonamiento basado en casos
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 */
Estudio para la implementación de un sistema de razonamiento basado en casos
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);
Estudio para la implementación de un sistema de razonamiento basado en casos
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) {
Estudio para la implementación de un sistema de razonamiento basado en casos
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);
Estudio para la implementación de un sistema de razonamiento basado en casos
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
*******************************************************************************************
**
Estudio para la implementación de un sistema de razonamiento basado en casos
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 );
Estudio para la implementación de un sistema de razonamiento basado en casos
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",
Estudio para la implementación de un sistema de razonamiento basado en casos
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);
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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. "));
Estudio para la implementación de un sistema de razonamiento basado en casos
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 ); }
Estudio para la implementación de un sistema de razonamiento basado en casos
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;
Estudio para la implementación de un sistema de razonamiento basado en casos
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><font " + "face=arial" + " size=10>CBR - EXTRACTION MODULE</font> </CENTER>"; HTML = HTML + "<CENTER><font " + "face=arial" + " size=2>Results of Similar Cases</font> </CENTER>"; HTML = HTML + "<table border=2 align=center cellspacing=0 bordercolor=#000000>"; //--- Column headers HTML = HTML + "<tr>"; HTML = HTML + "<th " + "align=center" + " bgcolor=#FF9900" + "><font " + "color=#FFFFFF" + "</font>"; HTML = HTML + "Rank"; HTML = HTML + "</th>"; HTML = HTML + "<th " + "align=center" + " bgcolor=#99CC00" + "><font " + "color=#FFFFFF" + "</font>"; HTML = HTML + "Similarity"; HTML = HTML + "</th>"; // column Names special columnNames.add("Rank"); columnNames.add("Similarity"); for (i=0; i < descriptorSize; i++ ) { // descriptors traitDescriptor = traitDescriptors.get( i ); traitName = traitDescriptor.getName(); if (traitDescriptor.getIncluded()== true){ // is visible attribute? HTML = HTML + "<th " + "align=center" + " bgcolor=#0099CC" + "><font " + "color=#FFFFFF" + "</font>"; HTML = HTML + traitName; HTML = HTML + "</th>"; columnNames.add(traitName); } } counter = 0; int numCasesDisplayed = 1; cursor = items.iterator(); while ( (cursor.hasNext()) && (numCasesDisplayed <= MAX_CASES_DISPLAYED) ) { // while exist items & Vector columns = new Vector(1,1); // numCasesDisplayed <= MaxCASES similarityDescription = (SimilarityDescription) cursor.next(); // next item Similar percentSimilarity = (int) (100 * similarityDescription.getPercentSimilarity()); // create % rank = similarityDescription.getRank(); item = similarityDescription.getItem(); if (percentSimilarity != 0 || similarity == false){ //if is diferent of 0% HTML = HTML + "<tr>"; HTML = HTML + "<td>"; HTML = HTML + rank ;
Estudio para la implementación de un sistema de razonamiento basado en casos
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(); }
Estudio para la implementación de un sistema de razonamiento basado en casos
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 <small>baylor</small> * */ public class SimilarItems { //----------------------------------------------------------------------------- // Attributes //----------------------------------------------------------------------------- //--- Sorted list of SimilarityDescription objects private ArrayList descriptions = new ArrayList(); //----------------------------------------------------------------------------- // Methods //----------------------------------------------------------------------------- /** add collection similar items * @param SimilarityDescription descriptor, item similarity
Estudio para la implementación de un sistema de razonamiento basado en casos
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) {
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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 <small>baylor</small> */ public class SimilarityCriteria { private ArrayList criteria = new ArrayList(); /** add to collection SimilarCriterion * @param SimilarityCriterion criterion * @exceptions Not Exceptions */ public void add( SimilarityCriterion criterion ) { criteria.add( criterion ); } //--- add /** add to collection SimilarCriterion * @param String fieldName, name Attribute * @param String operator, operator * @param String value, Value attribute * @exceptions Not Exceptions */ public void add( String fieldName, String operator, String value ) { SimilarityCriterion criterion = new SimilarityCriterion( fieldName, operator, value ); this.add( criterion ); } //--- add /** Clone object * @param not param * @return object * @exceptions Not Exceptions
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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()
Estudio para la implementación de un sistema de razonamiento basado en casos
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 <small>baylor</small> * */ public class SimilarityCriterionScore { //----------------------------------------------------------------------------- // Attributes //----------------------------------------------------------------------------- private String criterionID; private float normalizedValue; private float weightedValue; //----------------------------------------------------------------------------- // Constructors //----------------------------------------------------------------------------- protected SimilarityCriterionScore( String criterionID ) { setID( criterionID ); } //-----------------------------------------------------------------------------
Estudio para la implementación de un sistema de razonamiento basado en casos
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 <small>baylor</small> * */
Estudio para la implementación de un sistema de razonamiento basado en casos
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 <small>baylor</small> * */ public class SimilarityDescription implements Comparable { //----------------------------------------------------------------------------- // Attributes //----------------------------------------------------------------------------- private Item itemBeingDescribed;
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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 <small>baylor</small> * */ public class SimilarityEngine { //----------------------------------------------------------------------------- // Private Constants //----------------------------------------------------------------------------- private static final String MAX_VAL_INDICATOR = "[max_val]"; private static final String MIN_VAL_INDICATOR = "[min_val]"; //----------------------------------------------------------------------------- // Methods //----------------------------------------------------------------------------- /** Get compute Distance between Target values and Item values * @param SimilarityCriterionScores targetValues Values of target * @param SimilarityCriterionScores itemValues Values of item * @return Float Distance distance between they * @exceptions Not Exceptions */ private float computeDistance( SimilarityCriterionScores targetValues, SimilarityCriterionScores itemValues ) { float sum = 0; Iterator targetValueList = targetValues.iterator(); while (targetValueList.hasNext()) { //--- This is the score for one of the several criteria SimilarityCriterionScore targetScore = (SimilarityCriterionScore) targetValueList.next(); SimilarityCriterionScore itemScore = itemValues.get( targetScore.getID() ); float targetValue = targetScore.getWeightedValue(); float itemValue = itemScore.getWeightedValue(); float delta = (targetValue - itemValue);
Estudio para la implementación de un sistema de razonamiento basado en casos
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);
Estudio para la implementación de un sistema de razonamiento basado en casos
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 ) {
Estudio para la implementación de un sistema de razonamiento basado en casos
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,
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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;
Estudio para la implementación de un sistema de razonamiento basado en casos
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 <small>baylor</small> * */ public class SimilarityWeights { //----------------------------------------------------------------------------- // Attributes //----------------------------------------------------------------------------- protected HashMap weights = new HashMap(); //----------------------------------------------------------------------------- // Methods //----------------------------------------------------------------------------- /** Add HashMap Weights * @param String fieldname, name of attribute * @param int Weight, integer weight desire * @exceptions Not Exceptions */ public void add( String fieldName, int weight ) { //--- HashMaps require objects, no intrinsic data types
Estudio para la implementación de un sistema de razonamiento basado en casos
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.
Estudio para la implementación de un sistema de razonamiento basado en casos
220033
This class has been modified to comment the methods modified by Manuel Miguel Gimenez Arjona */ package net.sourceforge.selectionengine; /** * * @author <small>baylor</small> * */ public class Trait { //--- Attributes private String name = null; private TraitValue value = null; /** Set Name attribute & value * @param String name, name Attibute * @param String value, value Attribute * @exception Not Exceptions */ protected Trait( String name, String value ) { setName( name ); setValue( value ); } //--- constructor /** Return Name of Attribute * @param Not param * @return String Name * @exception Not Exceptions */ public String getName() { return name; } /** Return Value of Attribute * @param Not param * @return String value * @exception Not Exceptions */ public TraitValue getValue() { return value; } /** Set Name attribute * @param String name, name Attibute * @exception Not Exceptions */ protected void setName( String newName ) { this.name = newName; } //--- setName /** Set value of attribute * @param String newValue * @exception Not Exceptions */ protected void setValue( String newValue ) { this.value = new TraitValue( newValue ); } //--- setValue } //--- Trait *******************************************************************************************
TraitDescriptor.java
Estudio para la implementación de un sistema de razonamiento basado en casos
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; }
Estudio para la implementación de un sistema de razonamiento basado en casos
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( ) {
Estudio para la implementación de un sistema de razonamiento basado en casos
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 */
Estudio para la implementación de un sistema de razonamiento basado en casos
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++; // } }
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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() {
Estudio para la implementación de un sistema de razonamiento basado en casos
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;
Estudio para la implementación de un sistema de razonamiento basado en casos
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; }
Estudio para la implementación de un sistema de razonamiento basado en casos
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
*******************************************************************************************
/*
Estudio para la implementación de un sistema de razonamiento basado en casos
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 <small>baylor</small> * */ public class TraitStatistics { //----------------------------------------------------------------------------- // Attributes //----------------------------------------------------------------------------- private String traitName; private float minimumValue; private float maximumValue; private int numberOfExamples = 0; //----------------------------------------------------------------------------- // Constructors //----------------------------------------------------------------------------- public TraitStatistics( String traitName ) { setTraitName( traitName ); } //----------------------------------------------------------------------------- // Methods //----------------------------------------------------------------------------- /** Put minimum value and maximun value * @param Float value * @exceptions Not Exceptions */ public void addExample( float value ) { if (numberOfExamples == 0) { this.setMinimumValue( value ); this.setMaximumValue( value ); } else { if (value < getMinimumValue()) { this.setMinimumValue( value ); } if (value > getMaximumValue()) { this.setMaximumValue( value ); } } numberOfExamples++; } //--- addExample /** return Maximun value * @param Not Param * @return float maximum value
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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(); }
Estudio para la implementación de un sistema de razonamiento basado en casos
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(); } /**
Estudio para la implementación de un sistema de razonamiento basado en casos
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();
Estudio para la implementación de un sistema de razonamiento basado en casos
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);
Estudio para la implementación de un sistema de razonamiento basado en casos
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;
Estudio para la implementación de un sistema de razonamiento basado en casos
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 */
Estudio para la implementación de un sistema de razonamiento basado en casos
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;
Estudio para la implementación de un sistema de razonamiento basado en casos
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(); } });
Estudio para la implementación de un sistema de razonamiento basado en casos
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 );
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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 */
Estudio para la implementación de un sistema de razonamiento basado en casos
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",
Estudio para la implementación de un sistema de razonamiento basado en casos
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();
Estudio para la implementación de un sistema de razonamiento basado en casos
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 */
Estudio para la implementación de un sistema de razonamiento basado en casos
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;
Estudio para la implementación de un sistema de razonamiento basado en casos
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); }
Estudio para la implementación de un sistema de razonamiento basado en casos
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){
Estudio para la implementación de un sistema de razonamiento basado en casos
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); } } }
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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;
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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");
Estudio para la implementación de un sistema de razonamiento basado en casos
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); }
Estudio para la implementación de un sistema de razonamiento basado en casos
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;
Estudio para la implementación de un sistema de razonamiento basado en casos
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();
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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(),
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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
Estudio para la implementación de un sistema de razonamiento basado en casos
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);
Estudio para la implementación de un sistema de razonamiento basado en casos
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;
Estudio para la implementación de un sistema de razonamiento basado en casos
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 ); } }