The main goal of jCOLIBRI is to provide a reference platform for developing CBR applications. With the term “platform” we mean that it defines a clear architecture to design CBR systems plus a reference implementation of the components required to build them.
This architecture has been designed to be extensible and reusable across different domains and CBR families.

Although the main scope of the framework is the research community, a relevant feature of jCOLIBRI is its support for large scale commercial applications. It means that our software can be used not only to do rapid prototyping of CBR systems but also for developing applications that will be deployed in real scenarios. This feature is exemplified, for example, by its straightforward integration into web environments.

jCOLIBRI takes advantage of several years of experience from the first version released in 2005. Therefore, the current architecture solves many problems found in its predecessor but reuses the design choices that demonstrated to be good ideas.


Help us to improve jCOLIBRI. We are asking our users to fill the following survey. It will take a few minutes and your answers would be very useful for the future of the framework.

[Features] [Getting Started] [Content overview]
[Including jCOLIBRI into an existing development] [Extending jCOLIBRI]
[Build] [Third Party software packages] [License]

Features

jCOLIBRI includes the following features:

  • Persistence Layer. jCOLIBRI defines a clear interface between the media containing the cases (data base, textual files, ontologies, ARFF files, …) and the in-memory organization of the cases.
  • In-memory organization of the cases. Cases can be organized using different indexing structures: linear lists, trees, maps, etc.
  • Retrieval methods. The most important retrieval method is the Nearest Neighbour scoring. It uses global similarity functions to compare compound attributes and local similarity functions in order to compare simple attributes.
    Although this method is very popular, there are other methods that are also included in the framework. For example, we implement the Expert Clerk Median scoring and a filtering method that selects cases according to Boolean conditions over the attributes.
    For Textual CBR applications it provides specialized methods using several Information Retrieval or Information Extraction libraries (Apache Lucene, GATE, …).
    Regarding Knowledge Intensive CBR we enable the retrieval from ontologies.
    Data Intensive retrieval is faced by means of clustering algorithms and a connector for the Weka arff format.
    Once cases are retrieved, best ones are selected. The framework includes methods to select the best scored cases, but also the best cases that are also diverse.
  • Reuse and revision methods. These two stages are coupled to the specific domain of the application, so jCOLIBRI only includes simple methods to copy the solution from the case to the query, to copy only some attributes, or to compute direct proportions between the description and solution attributes. There are also specialized methods to adapt cases using ontologies.
  • Maintenance. The maintenance components allow developers to reduce the size of the case base. Provided components are: BBNR (Blame-based noise reduction), CRR (Conservative Redundancy Removal), RENN (Repeated Edited Nearest Neighbour), RC (Relative Cover), and ICF (Iterative Case Filtering).
  • Evaluation methods measure the performance of a CBR application. jCOLIBRI includes the following strategies: Hold Out, Leave One Out and N-Fold.
  • Visualization. This component lays out the distance between cases. This tool serves to debug the fitness of the similarity measure.
  • Examples. The examples included in jcolibri2 are useful in testing the framework and are part of its documentation.

Summarizing, jCOLIBRI offers 5 different retrieval strategies with 7 selection methods and provides more than 30 similarity metrics. It provides around 20 adaptation and maintenance components plus several extra tools like evaluation of systems or visualization of the case base.

Getting Started

Make sure that Java (1.6 or later) is installed on your computer.

After unzipping the jCOLIBRI zipped file in any directory, run the application tester that should be in the directory where jCOLIBRI was unzipped.

  • In Windows: jCOLIBRI2-Tester.bat
  • In UNIX: jCOLIBRI2-Tester.sh

The tester let you run every test application included in the release to exemplify the main features of jCOLIBRI. In the Tester you can access to the javadocs of the tests which are the main source of documentation.

There is also an example of using the jCOLIBRI jar library in a stand-alone application named “Travel Recommender”. It can be launched using the following scripts:

  • In Windows: TravelRecommender.bat
  • In UNIX: TravelRecommender.sh

Content overview

  • ./jCOLIBRI2-Tester.bat : The tester application for Windows.
  • ./jCOLIBRI2-Tester.sh : The tester application for Unix.
  • ./README.txt : File containing this information.
  • ./.project : Eclipse project file that can be imported into that IDE.
  • ./.classpath : Eclipse classpath file with the libraries used in jCOLIBRI.
  • ./build.xml : Apache Ant build file to compile the sources.
  • ./jcolibri2.LICENSE : License agreement.
  • ./src/jcolibri : The souce code of the jCOLIBRI package.
  • ./doc/api/index.html : The index to the javadoc of the jCOLIBRI package.
  • ./doc/uml/ : UML class and sequence diagrams.
  • ./doc/configfilesSchemas/ : XML schemas for the configuration files of the connectors used to stores persistent data
  • ./lib : jCOLIBRI as well as third-party libraries included in this release.
  • ./lib/jcolibri2.jar : Compiled jCOLIBRI jar file.
  • ./TravelRecommender : Folder for the Travel Recommender example.
  • ./TravelRecommender.bat : The Travel Recommender for Windows.
  • ./TravelRecommender.sh : The Travel Recommender for Unix.

Including jCOLIBRI into an existing development

Any application using jCOLIBRI should has access to ./lib/jcolibri2.jar along with all the jar files in ./lib/commons by including them in your CLASSPATH or directly in the JVM invocation:

java --classpath COLIBRI_HOME/lib/jcolibri2.jar;
COLIBRI_HOME/lib/commons/antlr-2.7.6.jar;
COLIBRI_HOME/lib/commons/commons-collections-3.2.jar;
COLIBRI_HOME/lib/commons/commons-logging-1.1.jar;
COLIBRI_HOME/lib/commons/dom4j-1.6.1.jar;
COLIBRI_HOME/lib/commons/junit.jar;
COLIBRI_HOME/lib/commons/log4j-1.2.14.jar;
COLIBRI_HOME/lib/commons/stax-api-1.0.1.jar;
<your.main.class>

Additional libraries should be included depending on the features of the CBR application being developed:

  • ./lib/databaseconnector : Database connection.
  • ./lib/ontobridge : Ontology management.
  • ./lib/textual : Textual CBR extension.
  • ./lib/evaluation : CBR system evaluation.
  • ./lib/visualization : Case Base visualization.

To facilitate the inclusion of libraries without polluting the CLASSPATH nor writing extremely long command lines, jCOLIBRI includes a launcher class that loads all the libraries at runtime reading the configuration from an XML file using the DTD of a .classpath file in Eclipse.

The main method of the jcolibri.util.Launcher class takes as first argument the main class of your CBR application and as second argument the file that stores the location of the libraries. This second argument is optional, so if not provided the launcher looks for a file named .classpath in the current directory. For example, the application tester can be invoked from the jCOLIBRI installation directory with:

java -cp lib/jcolibri2.jar jcolibri.util.Launcher jcolibri.test.main.MainTester

or, from any directory with:

java -cp COLIBRI_HOME/lib/jcolibri2.jar jcolibri.util.Launcher jcolibri.test.main.MainTester COLIBRI_HOME/.classpath

Extending jCOLIBRI

Import ./.project into Eclipse or use your favorite IDE to configure a project with the source files in ./src/jcolibri including all the libraries specified in ./.classpath and enjoy. We will be happy to consider any extension that you develop for inclusion in the main distribution.

Build

./build.xml is an Apache Ant build file that compiles the sources in ./src into ./bin, overwrites ./lib/jcolibri2.jar and generates the javadoc files into ./doc.

With Apache Ant installed in your computer, invoke it from the jCOLIBRI installation directory with:

ant 

or

ant all

(this will compile, create ./lib/jcolibri2.jar, and generate the javadoc)

if you want to generate only some elements use the following ant targets:

  • ant build : compiles the sources in ./src into ./bin
  • ant jar : creates the ./lib/jcolibri2.jar library
  • ant javadoc : generates the javadoc files into ./doc
  • ant clean : cleans the project

Third Party software packages

jCOLIBRI includes as jar files the following third-party software packages:

  • Carrot2 (http://www.carrot2.org): MIT license
  • Chart2D (http://chart2d.sourceforge.net/): LGPL
  • Gate (http://gate.ac.uk/): LGPL
  • Hibernate (http://www.hibernate.org): LGPL
  • Jena (http://jena.sourceforge.net): HP custom license
  • Lucene (http://lucene.apache.org): Apache License version 2
  • OpenNLP (http://opennlp.sourceforge.net): LGPL
  • Pellet (http://pellet.owldl.com/): MIT license
  • Wordnet (http://wordnet.princeton.edu/): See license at http://wordnet.princeton.edu/license

License

The source code is released under the terms of the GNU Lesser General Public License (LGPL).

Los comentarios están cerrados.